peachsim 0.1.2186 → 0.1.2188

package/src/java-module-abi.ts

@@ -0,0 +1,145 @@
+import { execFile } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import fs from 'node:fs'
+import path from 'node:path'
+import { promisify } from 'node:util'
+import { readBridgeMethod } from './android-bridge-packages'
+import { isRecord } from './is-record'
+import { kotlinHome } from './kotlin-toolchain'
+import type { JavaModuleSpec, JavaModuleSpecs } from './javaAbiContract'
+import type { KotlinToolchainInstallation } from './kotlinSdkContract'
+
+const run = promisify(execFile)
+export const JAVA_BINDINGS_INITIALIZER = 'initializeJavaBindings'
+
+export async function readJavaModuleSpecs(
+  files: string[],
+  sdkRoot: string,
+  toolchain: KotlinToolchainInstallation,
+): Promise<JavaModuleSpecs> {
+  const digest = createHash('sha256')
+  const parent = path.join(kotlinHome(), 'java-specs')
+  fs.mkdirSync(parent, { recursive: true })
+  const work = fs.mkdtempSync(path.join(parent, '.read-'))
+  try {
+    const origins = new Map<string, string>()
+    for (const [index, file] of files.entries()) {
+      const bytes = fs.readFileSync(file)
+      digest.update(file).update('\0').update(bytes).update('\0')
+      const target = path.join(work, String(index), path.basename(file))
+      fs.mkdirSync(path.dirname(target))
+      fs.writeFileSync(target, bytes)
+      origins.set(target, file)
+    }
+    const { stdout } = await run(
+      path.join(toolchain.javaHome, 'bin', 'java'),
+      [
+        '-cp',
+        [
+          path.join(sdkRoot, 'tools.jar'),
+          path.resolve(path.dirname(toolchain.kotlinc), '../lib/kotlin-compiler.jar'),
+          path.resolve(path.dirname(toolchain.kotlinc), '../lib/kotlin-stdlib.jar'),
+        ].join(path.delimiter),
+        'dev.peach.tools.javaabi.JavaModuleSpecsKt',
+        ...origins.keys(),
+      ],
+      { maxBuffer: 16 * 1024 * 1024 },
+    )
+    const specs = stdout
+      .split('\n')
+      .filter(Boolean)
+      .map((line): JavaModuleSpec => {
+        const row: unknown = JSON.parse(line)
+        if (
+          !isRecord(row) ||
+          typeof row.file !== 'string' ||
+          typeof row.className !== 'string' ||
+          (row.name !== null && typeof row.name !== 'string') ||
+          typeof row.source !== 'string' ||
+          !Array.isArray(row.methods)
+        )
+          throw new Error('Java module reader printed an invalid spec')
+        const file = origins.get(row.file)
+        if (!file) throw new Error('Java module reader named an unknown input')
+        return {
+          file,
+          className: row.className,
+          name: row.name,
+          source: row.source,
+          methods: row.methods.map(readBridgeMethod),
+        }
+      })
+    return { sha256: digest.digest('hex'), specs }
+  } finally {
+    fs.rmSync(work, { recursive: true, force: true })
+  }
+}
+
+export async function compileJavaModuleAbi(input: {
+  specs: JavaModuleSpecs
+  work: string
+  hash: string
+  toolchain: KotlinToolchainInstallation
+  libraries: string[]
+  sdkRoot: string
+  sdkLibrary: string
+  language: string
+}): Promise<string> {
+  const { specs, work, hash, toolchain, libraries, sdkRoot, sdkLibrary, language } = input
+  const directory = path.join(work, 'java-abi')
+  fs.mkdirSync(directory)
+  const sources = specs.specs.map((spec, index) => {
+    const target = path.join(directory, `Spec${index}.kt`)
+    fs.writeFileSync(target, spec.source)
+    return target
+  })
+  const initializer = path.join(directory, 'Bindings.kt')
+  fs.writeFileSync(
+    initializer,
+    [
+      'package dev.peach.jni',
+      `internal fun ${JAVA_BINDINGS_INITIALIZER}() { error("Java bindings require the compiler plugin") }`,
+    ].join('\n'),
+  )
+  const name = `peach-java-abi-${hash}`
+  await run(
+    toolchain.kotlinc,
+    [
+      '-J-Xmx2g',
+      '-Xwasm-target=js',
+      '-libraries',
+      libraries.join(path.delimiter),
+      `-Xplugin=${path.join(sdkRoot, 'plugin.jar')}`,
+      `-Xfriend-modules=${sdkLibrary}`,
+      '-language-version',
+      language,
+      '-api-version',
+      language,
+      '-nowarn',
+      '-ir-output-dir',
+      directory,
+      '-ir-output-name',
+      name,
+      ...sources,
+      initializer,
+    ],
+    { maxBuffer: 16 * 1024 * 1024 },
+  )
+  const library = path.join(directory, 'java-abi.klib')
+  await run(
+    path.join(toolchain.javaHome, 'bin', 'java'),
+    [
+      '-cp',
+      [
+        path.join(sdkRoot, 'tools.jar'),
+        path.resolve(path.dirname(toolchain.kotlinc), '../lib/kotlin-compiler.jar'),
+        path.resolve(path.dirname(toolchain.kotlinc), '../lib/kotlin-stdlib.jar'),
+      ].join(path.delimiter),
+      'dev.peach.tools.platform.JavaPlatformTypesKt',
+      path.join(directory, `${name}.klib`),
+      library,
+    ],
+    { maxBuffer: 16 * 1024 * 1024 },
+  )
+  return library
+}

package/src/javaAbiContract.ts

@@ -0,0 +1,14 @@
+import type { BridgeMethod } from './android-bridge-packages'
+
+export interface JavaModuleSpec {
+  file: string
+  className: string
+  name: string | null
+  source: string
+  methods: BridgeMethod[]
+}
+
+export interface JavaModuleSpecs {
+  sha256: string
+  specs: JavaModuleSpec[]
+}

package/src/kotlin-host.ts

@@ -20,6 +20,11 @@ import {
 } from './android-bridge-packages'
 import { rnxHomeDir } from './home-paths'
 import { isRecord } from './is-record'
+import {
+  compileJavaModuleAbi,
+  JAVA_BINDINGS_INITIALIZER,
+  readJavaModuleSpecs,
+} from './java-module-abi'
 import { kotlinInstanceSource } from './kotlin-instance-source'
 import { installKotlinSdkArchive } from './kotlin-sdk'
 import {
@@ -131,11 +136,12 @@ function entrySource(ids: string[]): string {
     '',
     '@OptIn(kotlin.js.ExperimentalJsExport::class)',
     '@JsExport',
-    'fun peachSetAndroidDeviceInfo(model: String, release: String, apiLevel: Int, locale: String, timeZone: String, settings: String) {',
+    'fun peachSetAndroidDeviceInfo(model: String, release: String, apiLevel: Int, locale: String, timeZone: String, settings: String, properties: String) {',
     '    Build.setDevice(model, release, apiLevel)',
     '    java.util.Locale.setDefault(java.util.Locale.forLanguageTag(locale))',
     '    java.util.TimeZone.setDevice(timeZone)',
     '    dev.peach.android.ProcessSettings.configure(settings)',
+    '    android.os.SystemProperties.configure(properties)',
     '}',
     '',
     '@OptIn(kotlin.js.ExperimentalJsExport::class, kotlinx.coroutines.DelicateCoroutinesApi::class)',
@@ -703,6 +709,25 @@ export async function expoKotlinArtifact(
   origin: string,
   modules: ExpoKotlinModules,
 ): Promise<KotlinArtifact & { compose: boolean }> {
+  if (modules.gradleSources) {
+    const { resolveAndroidGradleSources } = await import('./android-gradle-sources')
+    const projects = await resolveAndroidGradleSources(modules.gradleSources)
+    modules = {
+      ...modules,
+      sources: [
+        ...new Set([
+          ...modules.sources,
+          ...projects.flatMap((project) => project.kotlin),
+        ]),
+      ],
+      javaSpecs: [
+        ...new Set([
+          ...(modules.javaSpecs ?? []),
+          ...projects.flatMap((project) => project.java),
+        ]),
+      ],
+    }
+  }
   const toolchain = readToolchain(moduleRoot)
   const language = appKotlinLanguage(root)
   const scanned = await scanExpoTypes(toolchain, moduleRoot, modules.sources)
@@ -731,11 +756,12 @@ export async function expoKotlinArtifact(
     '    ))',
     '}',
     '',
-    '@JsExport fun peachSetAndroidDeviceInfo(model: String, release: String, apiLevel: Int, locale: String, timeZone: String, settings: String) {',
+    '@JsExport fun peachSetAndroidDeviceInfo(model: String, release: String, apiLevel: Int, locale: String, timeZone: String, settings: String, properties: String) {',
     '    android.os.Build.setDevice(model, release, apiLevel)',
     '    java.util.Locale.setDefault(java.util.Locale.forLanguageTag(locale))',
     '    java.util.TimeZone.setDevice(timeZone)',
     '    dev.peach.android.ProcessSettings.configure(settings)',
+    '    android.os.SystemProperties.configure(properties)',
     '    PeachExpoRuntime.configureProcessLocale(locale)',
     '}',
     '',
@@ -757,6 +783,7 @@ export async function expoKotlinArtifact(
       toolchain,
       language,
       sources: modules.sources.filter((file) => !rewritten.has(file)),
+      javaSpecs: modules.javaSpecs,
       generated: {
         ...types.generated,
         'PeachExpoEntry.kt': entry,
@@ -1109,6 +1136,7 @@ async function compileKotlin(
     toolchain: KotlinToolchain
     language: string
     sources: string[]
+    javaSpecs?: string[]
     generated: Record<string, string>
     // the app source a generated file rewrites, which its diagnostics name
     origins?: Record<string, string>
@@ -1137,10 +1165,14 @@ async function compileKotlin(
     usesCompose,
     usesSerialization = false,
     viewModels,
+    javaSpecs = [],
   } = input
   const sdk = await loadKotlinSdk(moduleRoot, toolchain)
   const plugin = path.join(sdk.root, 'plugin.jar')
   const sdkLibrary = path.join(sdk.root, `${sdkProfile}.klib`)
+  const java = javaSpecs.length
+    ? await readJavaModuleSpecs(javaSpecs, sdk.root, await ensureToolchain(toolchain))
+    : null
   const generated = {
     ...sourceGenerated,
     'PeachBindingsInitialization.kt': [
@@ -1152,6 +1184,7 @@ async function compileKotlin(
       '@JsExport fun peachInitializeModuleBindings() {',
       '    if (!initialized) {',
       '        requireIncomingBindings()',
+      ...(java ? [`        ${JAVA_BINDINGS_INITIALIZER}()`] : []),
       '        initializeApplicationIncomingBindings()',
       ...(sourceGenerated['PeachViews.kt']
         ? ['        initializeApplicationViews()']
@@ -1175,6 +1208,7 @@ async function compileKotlin(
       sdk: sdk.sha256,
       sdkProfile,
       usesSerialization,
+      java: java?.sha256,
     }),
   )
   for (const { file, bytes } of inputs)
@@ -1210,6 +1244,8 @@ async function compileKotlin(
     }
     fs.mkdirSync(buildsDir(), { recursive: true })
     const work = fs.mkdtempSync(path.join(buildsDir(), `${hash}-`))
+    const javaLibrary = java ? path.join(work, 'java-abi', 'java-abi.klib') : null
+    if (javaLibrary) libraries.push(javaLibrary)
     const generatedDir = path.join(work, 'generated')
     fs.mkdirSync(generatedDir)
     for (const [name, text] of Object.entries(generated))
@@ -1234,7 +1270,7 @@ async function compileKotlin(
         [
           ...common,
           `-Xplugin=${plugin}`,
-          `-Xfriend-modules=${sdkLibrary}`,
+          `-Xfriend-modules=${[sdkLibrary, ...(javaLibrary ? [javaLibrary] : [])].join(path.delimiter)}`,
           ...(usesCompose
             ? [
                 `-Xplugin=${path.resolve(path.dirname(kotlinc), '../lib/compose-compiler-plugin.jar')}`,
@@ -1261,6 +1297,17 @@ async function compileKotlin(
         { maxBuffer: 16 * 1024 * 1024 },
       )
     try {
+      if (java)
+        await compileJavaModuleAbi({
+          specs: java,
+          work,
+          hash,
+          toolchain: ready,
+          libraries: libraries.filter((library) => library !== javaLibrary),
+          sdkRoot: sdk.root,
+          sdkLibrary,
+          language,
+        })
       // the compiler resolves the app's classes and constructors: a first
       // klib's ABI names the view models the generated factory builds. an app
       // whose sources never name ViewModel declares none and skips it
@@ -1397,6 +1444,11 @@ async function compileKotlin(
         output = output
           .replaceAll(target, file)
           .replaceAll(path.relative(process.cwd(), target), file)
+      for (const [index, spec] of (java?.specs ?? []).entries())
+        output = output.replaceAll(
+          path.join(work, 'java-abi', `Spec${index}.kt`),
+          spec.file,
+        )
       throw new Error(
         `kotlin compile failed:\n${output.trim() || (error instanceof Error ? error.message : String(error))}`,
       )

package/src/nitro-source.ts

@@ -1,15 +1,13 @@
-import { execFile } from 'node:child_process'
 import { createHash } from 'node:crypto'
 import fs from 'node:fs'
 import { createRequire } from 'node:module'
 import path from 'node:path'
-import { promisify } from 'node:util'
-import { PEACH_FORKED_SCRIPT_ENV } from './forked-script-contract'
 import {
   nitroDependencyIncludes,
   nitroDependencyReader,
   prepareNitroDependencies,
 } from './nitro-dependencies'
+import { reactNativeAutolinkingConfig } from './react-native-autolinking'
 import { projectSourceKey, readPackageFile } from './swift-source-file'
 import { MAX_SWIFT_COMPILE_SOURCE_BYTES } from './swift-submit'
 import type { NitroView } from './nitroContract'
@@ -33,24 +31,6 @@ export type NitroSourceOptions = { packageRoots: string[]; answers?: NitroAnswer
     }
 )
 
-const run = promisify(execFile)
-
-// an autolinker that exits 0 with unparseable stdout names what it printed,
-// so a truncated or empty pipe read is distinguishable from a bad command.
-function autolinkerJson(
-  command: string,
-  output: { stdout: string; stderr: string },
-): unknown {
-  try {
-    return JSON.parse(output.stdout)
-  } catch (cause) {
-    throw new Error(
-      `${command} exited 0 with ${output.stdout.length} bytes of stdout that is not JSON (${cause instanceof Error ? cause.message : cause}); stderr: ${output.stderr.trim().slice(0, 500) || '(empty)'}; stdout: ${output.stdout.slice(0, 200) || '(empty)'}`,
-      { cause },
-    )
-  }
-}
-
 type NitroPackage = { name: string; version: string; root: string }
 
 export const nitroProviderTarget = (provider: Pick<NitroPackage, 'name'>) =>
@@ -378,150 +358,6 @@ export function selectNitroProviders(
     .filter(({ selected }) => selected.length > 0)
 }
 
-// whether the app's installed CLI advertises a command or flag. old Expo
-// autolinkers predate `react-native-config` and old React Native CLIs predate
-// `config --platform`, so both are probed rather than assumed.
-// the cli runs from the app root, as its real command does: react-native cli
-// 6 exits 1 with no output when it finds no project in its cwd
-async function cliAdvertises(
-  cli: string,
-  args: string[],
-  token: string,
-  appRoot: string,
-  signal?: AbortSignal,
-): Promise<boolean> {
-  const { stdout, stderr } = await run('node', [cli, ...args], {
-    cwd: appRoot,
-    signal,
-    timeout: 30_000,
-    maxBuffer: 1 * 1024 * 1024,
-    env: { ...process.env, [PEACH_FORKED_SCRIPT_ENV]: '1' },
-  })
-  if (!stdout.trim())
-    throw new Error(
-      `${cli} ${args.join(' ')} returned empty help output${stderr.trim() ? `: ${stderr.trim()}` : ''}`,
-    )
-  return stdout.includes(token)
-}
-
-function declaresDependency(appRoot: string, name: string): boolean {
-  const manifest: unknown = JSON.parse(
-    fs.readFileSync(path.join(appRoot, 'package.json'), 'utf8'),
-  )
-  return (
-    object(manifest) &&
-    ['dependencies', 'devDependencies'].some((field) => {
-      const group = manifest[field]
-      return object(group) && Object.hasOwn(group, name)
-    })
-  )
-}
-
-async function autolinkingConfig(
-  appRoot: string,
-  appRequire: NodeJS.Require,
-  signal?: AbortSignal,
-): Promise<unknown> {
-  // a pnpm app reaches the autolinker only through expo's own dependencies
-  const expoManifest = appRequire.resolve
-    .paths('expo')
-    ?.map((directory) => path.join(directory, 'expo/package.json'))
-    .find((manifest) => fs.existsSync(manifest))
-  const expoRequire = expoManifest
-    ? createRequire(fs.realpathSync(expoManifest))
-    : appRequire
-  // the app's autolinking contract is the command its Podfile hands
-  // use_native_modules!: expo's react-native-config, or the React Native CLI
-  // when it passes none (expo's loader ignores react-native.config.cjs, which
-  // the CLI reads). a gitignored ios project is prebuild output, so without a
-  // Podfile the prebuild that would write it answers: expo's for an app that
-  // declares expo, One's bare use_native_modules! otherwise. an Expo Podfile
-  // holds both commands and runs the CLI's when EXPO_USE_COMMUNITY_AUTOLINKING
-  // is 1.
-  const podfile = path.join(appRoot, 'ios/Podfile')
-  const asksExpo =
-    process.env.EXPO_USE_COMMUNITY_AUTOLINKING !== '1' &&
-    (fs.existsSync(podfile)
-      ? fs.readFileSync(podfile, 'utf8').includes('expo-modules-autolinking')
-      : declaresDependency(appRoot, 'expo'))
-  const expoAutolinker = asksExpo
-    ? [appRequire, expoRequire]
-        .flatMap((req) => req.resolve.paths('expo-modules-autolinking') ?? [])
-        .map((directory) => path.join(directory, 'expo-modules-autolinking/package.json'))
-        .find((manifest) => fs.existsSync(manifest))
-    : undefined
-  if (expoAutolinker) {
-    const cli = path.join(path.dirname(expoAutolinker), 'bin/expo-modules-autolinking.js')
-    // autolinkers before the `react-native-config` command (Expo SDK 48 ships
-    // 1.2.0) cannot answer the React Native dependency map; those apps fall
-    // through to their own `react-native config`, the command their Podfile's
-    // use_native_modules! runs.
-    if (await cliAdvertises(cli, ['--help'], 'react-native-config', appRoot, signal)) {
-      const args = [
-        cli,
-        'react-native-config',
-        '--json',
-        '--platform',
-        'ios',
-        '--project-root',
-        appRoot,
-      ]
-      return autolinkerJson(
-        'expo-modules-autolinking react-native-config',
-        await run('node', args, {
-          timeout: 30_000,
-          maxBuffer: 8 * 1024 * 1024,
-          env: { ...process.env, [PEACH_FORKED_SCRIPT_ENV]: '1' },
-          // expo's react-native.config.js calls findProjectRootSync() on the
-          // process cwd and ignores --project-root. the corpus bridge starts
-          // outside the app, where that walk finds no package.json.
-          cwd: appRoot,
-          signal,
-        }),
-      )
-    }
-  }
-  // the app's own `react-native config`, the command its Podfile runs, so any
-  // CLI release answers through one interface
-  // One's generated Podfile resolves the community CLI from vxrn.
-  const cliRequire = declaresDependency(appRoot, 'one')
-    ? createRequire(
-        createRequire(appRequire.resolve('one/package.json')).resolve(
-          'vxrn/package.json',
-        ),
-      )
-    : appRequire
-  const cliManifest = cliRequire.resolve('@react-native-community/cli/package.json')
-  const cli: unknown = JSON.parse(fs.readFileSync(cliManifest, 'utf8'))
-  const bins = object(cli) && object(cli.bin) ? cli.bin : undefined
-  // the bin was renamed from `react-native` to `rnc-cli` along the way; both
-  // point at the same entry.
-  const bin = [bins?.['rnc-cli'], bins?.['react-native']].find(
-    (entry): entry is string => typeof entry === 'string',
-  )
-  if (bin === undefined) throw new Error(`${cliManifest} declares no CLI bin`)
-  const cliPath = path.join(path.dirname(cliManifest), bin)
-  const configArgs = (await cliAdvertises(
-    cliPath,
-    ['config', '--help'],
-    '--platform',
-    appRoot,
-    signal,
-  ))
-    ? ['config', '--platform', 'ios']
-    : ['config']
-  return autolinkerJson(
-    `react-native ${configArgs.join(' ')}`,
-    await run('node', [cliPath, ...configArgs], {
-      cwd: appRoot,
-      signal,
-      timeout: 30_000,
-      maxBuffer: 16 * 1024 * 1024,
-      env: { ...process.env, [PEACH_FORKED_SCRIPT_ENV]: '1', NO_COLOR: '1' },
-    }),
-  )
-}
-
 /** the packages react native's iOS autolinking links into the app that ship a
  * generated Nitro iOS initializer. The app's own autolinker resolves the
  * dependencies, so local roots from react-native.config and platform exclusions
@@ -541,8 +377,7 @@ export async function iosAutolinkingConfig(
   appRoot: string,
   signal?: AbortSignal,
 ): Promise<unknown> {
-  const root = fs.realpathSync(appRoot)
-  return autolinkingConfig(root, createRequire(path.join(root, 'package.json')), signal)
+  return reactNativeAutolinkingConfig(appRoot, 'ios', signal)
 }
 
 /** every dependency React Native iOS autolinking links into the app, with the

package/src/react-native-autolinking.ts

@@ -0,0 +1,153 @@
+import { execFile } from 'node:child_process'
+import fs from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { promisify } from 'node:util'
+import { PEACH_FORKED_SCRIPT_ENV } from './forked-script-contract'
+import { isRecord } from './is-record'
+
+const run = promisify(execFile)
+function autolinkerJson(
+  command: string,
+  output: { stdout: string; stderr: string },
+): unknown {
+  try {
+    return JSON.parse(output.stdout)
+  } catch (cause) {
+    throw new Error(
+      `${command} exited 0 with ${output.stdout.length} bytes of stdout that is not JSON (${cause instanceof Error ? cause.message : cause}); stderr: ${output.stderr.trim().slice(0, 500) || '(empty)'}; stdout: ${output.stdout.slice(0, 200) || '(empty)'}`,
+      { cause },
+    )
+  }
+}
+
+// old CLI releases lack platform flags and Expo’s React Native command.
+async function cliAdvertises(
+  cli: string,
+  args: string[],
+  token: string,
+  appRoot: string,
+  signal?: AbortSignal,
+): Promise<boolean> {
+  const { stdout, stderr } = await run('node', [cli, ...args], {
+    cwd: appRoot,
+    signal,
+    timeout: 30_000,
+    maxBuffer: 1 * 1024 * 1024,
+    env: { ...process.env, [PEACH_FORKED_SCRIPT_ENV]: '1' },
+  })
+  if (!stdout.trim())
+    throw new Error(
+      `${cli} ${args.join(' ')} returned empty help output${stderr.trim() ? `: ${stderr.trim()}` : ''}`,
+    )
+  return stdout.includes(token)
+}
+
+function declaresDependency(appRoot: string, name: string): boolean {
+  const manifest: unknown = JSON.parse(
+    fs.readFileSync(path.join(appRoot, 'package.json'), 'utf8'),
+  )
+  return (
+    isRecord(manifest) &&
+    ['dependencies', 'devDependencies'].some((field) => {
+      const group = manifest[field]
+      return isRecord(group) && Object.hasOwn(group, name)
+    })
+  )
+}
+
+export async function reactNativeAutolinkingConfig(
+  appRoot: string,
+  platform: 'ios' | 'android',
+  signal?: AbortSignal,
+): Promise<unknown> {
+  appRoot = fs.realpathSync(appRoot)
+  const appRequire = createRequire(path.join(appRoot, 'package.json'))
+  const expoManifest = appRequire.resolve
+    .paths('expo')
+    ?.map((directory) => path.join(directory, 'expo/package.json'))
+    .find((manifest) => fs.existsSync(manifest))
+  const expoRequire = expoManifest
+    ? createRequire(fs.realpathSync(expoManifest))
+    : appRequire
+  const nativeFile = (
+    platform === 'ios'
+      ? ['ios/Podfile']
+      : ['android/settings.gradle', 'android/settings.gradle.kts']
+  )
+    .map((name) => path.join(appRoot, name))
+    .find((file) => fs.existsSync(file))
+  const nativeSource = nativeFile ? fs.readFileSync(nativeFile, 'utf8') : null
+  const asksExpo =
+    process.env.EXPO_USE_COMMUNITY_AUTOLINKING !== '1' &&
+    (nativeSource === null
+      ? declaresDependency(appRoot, 'expo')
+      : nativeSource.includes('expo-modules-autolinking') ||
+        (platform === 'android' &&
+          nativeSource.includes('expoAutolinking.rnConfigCommand')))
+  const expoAutolinker = asksExpo
+    ? [appRequire, expoRequire]
+        .flatMap((req) => req.resolve.paths('expo-modules-autolinking') ?? [])
+        .map((directory) => path.join(directory, 'expo-modules-autolinking/package.json'))
+        .find((manifest) => fs.existsSync(manifest))
+    : undefined
+  if (expoAutolinker) {
+    const cli = path.join(path.dirname(expoAutolinker), 'bin/expo-modules-autolinking.js')
+    if (await cliAdvertises(cli, ['--help'], 'react-native-config', appRoot, signal)) {
+      const args = [
+        cli,
+        'react-native-config',
+        '--json',
+        '--platform',
+        platform,
+        '--project-root',
+        appRoot,
+      ]
+      return autolinkerJson(
+        'expo-modules-autolinking react-native-config',
+        await run('node', args, {
+          timeout: 30_000,
+          maxBuffer: 8 * 1024 * 1024,
+          env: { ...process.env, [PEACH_FORKED_SCRIPT_ENV]: '1' },
+          // expo configuration resolves its project from cwd.
+          cwd: appRoot,
+          signal,
+        }),
+      )
+    }
+  }
+  const cliRequire = declaresDependency(appRoot, 'one')
+    ? createRequire(
+        createRequire(appRequire.resolve('one/package.json')).resolve(
+          'vxrn/package.json',
+        ),
+      )
+    : appRequire
+  const cliManifest = cliRequire.resolve('@react-native-community/cli/package.json')
+  const cli: unknown = JSON.parse(fs.readFileSync(cliManifest, 'utf8'))
+  const bins = isRecord(cli) && isRecord(cli.bin) ? cli.bin : undefined
+  const bin = [bins?.['rnc-cli'], bins?.['react-native']].find(
+    (entry): entry is string => typeof entry === 'string',
+  )
+  if (bin === undefined) throw new Error(`${cliManifest} declares no CLI bin`)
+  const cliPath = path.join(path.dirname(cliManifest), bin)
+  const configArgs = (await cliAdvertises(
+    cliPath,
+    ['config', '--help'],
+    '--platform',
+    appRoot,
+    signal,
+  ))
+    ? ['config', '--platform', platform]
+    : ['config']
+  return autolinkerJson(
+    `react-native ${configArgs.join(' ')}`,
+    await run('node', [cliPath, ...configArgs], {
+      cwd: appRoot,
+      signal,
+      timeout: 30_000,
+      maxBuffer: 16 * 1024 * 1024,
+      env: { ...process.env, [PEACH_FORKED_SCRIPT_ENV]: '1', NO_COLOR: '1' },
+    }),
+  )
+}