peachsim 0.1.1620 → 0.1.1635

package/src/expo-swift-ready.ts

@@ -0,0 +1,78 @@
+// an app with local Expo Swift modules only renders once the bridge compiles
+// them, and a cold /__peach/expo-swift artifact compiles for minutes (a linked
+// build plus per-namespace isolation builds in sequence) while a flow waits
+// 120s for its first tree. so `peach open` GETs the same endpoint the engine
+// will fetch and returns only once it answers; the bridge shares one compile
+// per root, so the engine's own fetch then finds it done. a warm artifact
+// answers in ~1s and an app without local modules answers null fast.
+export const EXPO_SWIFT_READY_TIMEOUT_MS = 30 * 60_000
+const EXPO_SWIFT_READY_PROGRESS_MS = 30_000
+
+export type ExpoSwiftReadyOptions = {
+  timeoutMs?: number
+  progressMs?: number
+  signal?: AbortSignal
+  onProgress?: (elapsedMs: number) => void
+}
+
+export async function awaitExpoSwiftReady(
+  endpointUrl: string,
+  options: ExpoSwiftReadyOptions = {},
+): Promise<void> {
+  const timeoutMs = options.timeoutMs ?? EXPO_SWIFT_READY_TIMEOUT_MS
+  const progressMs = options.progressMs ?? EXPO_SWIFT_READY_PROGRESS_MS
+  const start = Date.now()
+  const report =
+    options.onProgress ??
+    ((elapsedMs: number) => {
+      console.log(
+        `  still waiting on ${endpointUrl} after ${Math.round(elapsedMs / 1000)}s — expo swift compile in progress`,
+      )
+    })
+  const progress = setInterval(() => report(Date.now() - start), progressMs)
+  try {
+    options.signal?.throwIfAborted()
+    const timeout = AbortSignal.timeout(timeoutMs)
+    const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout
+    let res: Response | undefined
+    while (!res) {
+      try {
+        // bun ends an unanswered fetch at six minutes. that close is the last
+        // client, so the bridge aborts the shared compile and the retry starts
+        // over. hold the socket for the caller's bound instead.
+        const init: RequestInit = { signal }
+        Object.assign(init, { timeout: false })
+        res = await fetch(endpointUrl, init)
+      } catch (error) {
+        if (options.signal?.aborted) throw error
+        if (timeout.aborted) {
+          throw new Error(
+            `timed out after ${timeoutMs}ms waiting for ${endpointUrl} — the expo swift compile did not answer within the bound`,
+          )
+        }
+        // a dropped socket still rejoins the same compile when the bridge has
+        // another client. retry only that case.
+        if (error instanceof Error && error.name === 'TimeoutError') continue
+        throw new Error(`could not reach ${endpointUrl}`, { cause: error })
+      }
+    }
+    if (!res.ok) {
+      const body = (await res.text()).trim().slice(0, 500)
+      throw new Error(`${endpointUrl} answered ${res.status}${body ? `: ${body}` : ''}`)
+    }
+    await res.text()
+    console.log(
+      `  expo swift modules ready in ${((Date.now() - start) / 1000).toFixed(1)}s`,
+    )
+  } finally {
+    clearInterval(progress)
+  }
+}
+
+// the expoSwift endpoint a built shell url carries, or null for an app with no
+// project root
+export async function awaitStampedExpoSwiftReady(shellUrl: string): Promise<void> {
+  const endpoint = new URL(shellUrl).searchParams.get('expoSwift')
+  if (!endpoint) return
+  await awaitExpoSwiftReady(endpoint)
+}

package/src/expoSwiftContract.ts

@@ -1,10 +1,20 @@
 import { insertBundleGlobalFooter, readBundleGlobalFooter } from './bundleGlobalFooter'
 
+export interface ExpoSwiftPreparationOptions {
+  signal?: AbortSignal
+  timeoutMs?: number
+}
+
 export interface ExpoSwiftSourceUnit {
   namespace: string
   moduleId: string
   classes: string[]
+  // legacy bridge module registrations (react-native-bridge-modules.ts)
+  bridgeModules: string[]
   files: Record<string, string>
+  frameworks: string[]
+  // the app target's Swift language mode; Expo packages compile in the default
+  swiftLanguageMode?: number
 }
 
 export interface ExpoSwiftCompiledModule {
@@ -17,6 +27,8 @@ export interface ExpoSwiftCompiledModule {
 
 export interface ExpoSwiftCompilationResult {
   namespaces: string[]
+  // the namespaces that are legacy bridge modules rather than Expo modules
+  bridgeModules?: string[]
   modules: ExpoSwiftCompiledModule[]
   failures: { namespace: string; diagnostic: string }[]
 }
@@ -41,6 +53,13 @@ export function isExpoSwiftCompilationResult(
     return false
   const remaining = new Set(value.namespaces)
   if (remaining.size !== value.namespaces.length) return false
+  // bundles published before legacy bridge modules carry no list
+  if (
+    value.bridgeModules !== undefined &&
+    (!strings(value.bridgeModules) ||
+      !value.bridgeModules.every((name) => remaining.has(name)))
+  )
+    return false
   for (const artifact of value.modules) {
     if (
       !record(artifact) ||

package/src/home-paths.ts

@@ -185,6 +185,15 @@ export function cacheDir(): string {
   return path.join(rnxHomeDir(), 'cache')
 }
 
+// swiftpm otherwise uses shared caches and configuration outside PEACH_HOME.
+export function swiftPackageCacheOptions(): string[] {
+  const root = path.join(cacheDir(), 'swiftpm')
+  return ['cache', 'config', 'security'].flatMap((name) => [
+    `--${name}-path`,
+    path.join(root, name),
+  ])
+}
+
 export function daemonLockfilePath(): string {
   return path.join(rnxHomeDir(), DAEMON_LOCKFILE)
 }
@@ -261,7 +270,10 @@ export function writeSharedConfig(patch: Partial<SharedConfig>): SharedConfig {
   return next
 }
 
-const CURRENT_ONBOARDING_VERSION = 1
+// version 2 made the native app the default simulator window. version 1 setup
+// saved the browser without asking on a Mac lacking the app, so its saved
+// driver is not read back and those machines run setup again.
+const CURRENT_ONBOARDING_VERSION = 2
 
 export type SimulatorDriverPreference = DriverId
 
@@ -270,7 +282,9 @@ export function isOnboardingComplete(): boolean {
 }
 
 export function readSimulatorDriverPreference(): SimulatorDriverPreference | null {
-  const driver = readSharedConfig().simulatorDriver
+  const config = readSharedConfig()
+  if (config.onboardingVersion !== CURRENT_ONBOARDING_VERSION) return null
+  const driver = config.simulatorDriver
   return driver === 'desktop' || driver === 'electron' || driver === 'playwright'
     ? driver
     : null
@@ -634,6 +648,38 @@ export function isDevBridgeLockfileFresh(
   }
 }
 
+function hostBridgePortNumber(value: number | null | undefined): number | null {
+  if (typeof value !== 'number' || !Number.isInteger(value) || value < 1 || value > 65535)
+    return null
+  return value
+}
+
+/** port a desktop host's page should register on.
+ *
+ *  the launch url's wsPort pin wins. an ambient PEACH_BRIDGE_PORT wins only
+ *  when this home has no fresh daemon, the daemon already bound that port, or
+ *  a fresh dev-bridge lockfile in this home claims it. otherwise the fresh
+ *  daemon lock wins, so a second PEACH_HOME is not pulled onto another world's
+ *  bridge. the mac user script and the native seed use the same rule. */
+export function desktopHostBridgePort(input: {
+  pinnedPort?: number | null
+  daemonPort?: number | null
+  envPort?: number | null
+  devBridgePorts?: readonly number[]
+}): number | null {
+  const pinned = hostBridgePortNumber(input.pinnedPort)
+  if (pinned != null) return pinned
+  const daemon = hostBridgePortNumber(input.daemonPort)
+  const env = hostBridgePortNumber(input.envPort)
+  const claimed = new Set(
+    (input.devBridgePorts ?? [])
+      .map((port) => hostBridgePortNumber(port))
+      .filter((port): port is number => port != null),
+  )
+  if (env != null && (daemon == null || env === daemon || claimed.has(env))) return env
+  return daemon
+}
+
 export function readLiveRuntimeVersions(): string[] {
   const versions = new Set<string>()
   const daemon = readDaemonLockfile()

package/src/host/bridge-host.ts

@@ -474,9 +474,9 @@ export class SootSimBridgeHost {
   // can't immediately reclaim while the user gets oriented.
   private static USER_BOOT_LEASE_TTL_MS = 60_000
   private static SIM_RECONNECT_TTL_MS = 30_000
-  // abandoned-tab GC. the ws heartbeat only reaps sims whose socket went
-  // dead — but a background tab from a prior `peach open` / QA / test run
-  // keeps its socket alive (the page still pongs) forever, so `peach list`
+  // abandoned-tab GC. transport keepalive only reaps broken connections,
+  // but a background tab from a prior `peach open` / QA / test run
+  // keeps its socket alive forever, so `peach list`
   // accretes dozens of zombie sims that all time out on every command (QA
   // F21-3, carried F19-2). reap a sim only when it is provably nobody's:
   // not primary, not user-focused, no CLI attached, no active lease, and no
@@ -496,15 +496,6 @@ export class SootSimBridgeHost {
   private startedAt = 0
   private heartbeatTimer: NodeJS.Timeout | null = null
   private devHeartbeatTimer: NodeJS.Timeout | null = null
-  // ws-level heartbeat: sims that hang up uncleanly (page navigated, network
-  // dropped, sim crashed) leave their server-side WebSocket sitting "open"
-  // forever. ping every WS_HEARTBEAT_INTERVAL_MS; if the previous round's
-  // ping was never answered, terminate(). that fires 'close' which runs the
-  // sim-cleanup path and stops `peach list` from showing 8 zombie
-  // sims that all time out on every command.
-  private wsHeartbeatTimer: NodeJS.Timeout | null = null
-  private wsIsAlive = new WeakMap<WebSocket, boolean>()
-  private static WS_HEARTBEAT_INTERVAL_MS = 30_000
   private runtimeUpdateTimer: NodeJS.Timeout | null = null
   private runtimeUpdateInFlight: Promise<void> | null = null
   private readonly handleServerScan = createServerScanHandler({
@@ -552,10 +543,13 @@ export class SootSimBridgeHost {
     if (this.httpServer || this.wss) return this.effectivePort
 
     // an installed runtime can serve while the startup update runs. only a
-    // machine without usable assets needs to wait for that download.
+    // machine without usable assets needs to wait for that download. only the
+    // daemon's runtime updater ever clears the flag, so a dev bridge (which
+    // serves the checkout build and runs no updater) never sets it.
     const bootRuntimeDir = this.getActiveRuntime().runtimeDir
     this.bootstrapping =
-      !bootRuntimeDir || !fs.existsSync(path.join(bootRuntimeDir, 'index.html'))
+      this.shouldWriteLockfile &&
+      (!bootRuntimeDir || !fs.existsSync(path.join(bootRuntimeDir, 'index.html')))
 
     for (let attempt = 0; attempt < this.portFallbackCount; attempt++) {
       const candidate = this.preferredPort === 0 ? 0 : this.preferredPort + attempt
@@ -670,14 +664,10 @@ export class SootSimBridgeHost {
       // 'close' fires right after and runs the cleanup below.
       ws.on('error', () => {})
 
-      // ws-level heartbeat. pong responses come for free from the ws
-      // protocol — we just need to track them so the heartbeat sweep
-      // (started in afterBind) can terminate connections that stop
-      // answering. fresh connections start alive.
-      this.wsIsAlive.set(ws, true)
-      ws.on('pong', () => {
-        this.wsIsAlive.set(ws, true)
-      })
+      // the kernel answers keepalive during SIGSTOP. application pings would
+      // mistake a governor-paused render for a dead connection and discard it.
+      // command deadlines still bound an unresponsive application.
+      req.socket.setKeepAlive(true, 30_000)
 
       // register the socket with the agent host so session-status pushes
       // reach it even before it subscribes to any specific session, and so
@@ -1211,12 +1201,6 @@ export class SootSimBridgeHost {
     ) as unknown as NodeJS.Timeout
     this.cliIdleTimer.unref()
 
-    this.wsHeartbeatTimer = setInterval(
-      () => this.sweepDeadWebSockets(),
-      SootSimBridgeHost.WS_HEARTBEAT_INTERVAL_MS,
-    ) as unknown as NodeJS.Timeout
-    this.wsHeartbeatTimer.unref()
-
     if (this.shouldWriteLockfile) {
       try {
         ensureRnxHome()
@@ -2131,31 +2115,6 @@ export class SootSimBridgeHost {
     return queue.tickets.length > queue.limit
   }
 
-  // ping every connected ws; if the previous round's ping went unanswered,
-  // terminate the socket so 'close' fires and the sim cleanup path
-  // runs. matches the recommended ws-library heartbeat pattern.
-  private sweepDeadWebSockets() {
-    if (!this.wss) return
-    for (const ws of this.wss.clients) {
-      if (ws.readyState !== WebSocket.OPEN) continue
-      const alive = this.wsIsAlive.get(ws)
-      if (alive === false) {
-        try {
-          ws.terminate()
-        } catch {}
-        continue
-      }
-      this.wsIsAlive.set(ws, false)
-      try {
-        ws.ping()
-      } catch {
-        try {
-          ws.terminate()
-        } catch {}
-      }
-    }
-  }
-
   private closeSimSocketFromHost(ws: WebSocket, initiatedBy?: string) {
     if (ws.readyState !== WebSocket.OPEN) return
     if (initiatedBy) this.hostCloseCauseBySocket.set(ws, initiatedBy)
@@ -2302,10 +2261,6 @@ export class SootSimBridgeHost {
       clearInterval(this.devHeartbeatTimer)
       this.devHeartbeatTimer = null
     }
-    if (this.wsHeartbeatTimer) {
-      clearInterval(this.wsHeartbeatTimer)
-      this.wsHeartbeatTimer = null
-    }
     if (this.runtimeUpdateTimer) {
       clearInterval(this.runtimeUpdateTimer)
       this.runtimeUpdateTimer = null

package/src/host/staged-host-files.ts

@@ -2,6 +2,10 @@ import { createHash, randomUUID } from 'node:crypto'
 import fs from 'node:fs'
 import path from 'node:path'
 import { cacheDir } from '../home-paths'
+import {
+  LAUNCH_METADATA_KEYS,
+  LAUNCH_METADATA_QUERY_PARAM,
+} from '../launchMetadataContract'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 
 // local files a sim loads from the bridge: native-linked app fonts and
@@ -22,10 +26,33 @@ function contentType(extension: string | undefined): string {
     : 'application/octet-stream'
 }
 
+export function stageHostLaunchMetadata(url: URL, origin: string): string {
+  const metadata = new URLSearchParams()
+  for (const key of LAUNCH_METADATA_KEYS) {
+    for (const value of url.searchParams.getAll(key)) metadata.append(key, value)
+    url.searchParams.delete(key)
+  }
+  if (metadata.size > 0) {
+    const reference = stageHostBytes(
+      new TextEncoder().encode(metadata.toString()),
+      origin,
+    )
+    url.searchParams.set(LAUNCH_METADATA_QUERY_PARAM, reference)
+  }
+  return url.toString()
+}
+
 export function stageHostFile(filePath: string, origin: string): string {
-  const bytes = fs.readFileSync(filePath)
+  return stageHostBytes(fs.readFileSync(filePath), origin, path.extname(filePath))
+}
+
+export function stageHostBytes(
+  bytes: Uint8Array,
+  origin: string,
+  extension = '',
+): string {
   const digest = createHash('sha256').update(bytes).digest('hex')
-  const extension = path.extname(filePath).toLowerCase()
+  extension = extension.toLowerCase()
   const name = STAGED_NAME.test(digest + extension) ? digest + extension : digest
   const directory = stagedDir()
   const destination = path.join(directory, name)

package/src/installed-package-versions.ts

@@ -6,11 +6,12 @@
 import fs from 'fs'
 import path from 'path'
 import { LAZY_STUB_PATTERNS } from '@peach/compat/lazy-stub-patterns'
+import { NATIVE_RUNTIME_PACKAGE_NAMES } from '@peach/compat/native-package-names'
 import { COMPAT_STUBS } from '@peach/compat/stub-manifest'
 import { extractPackageFromPath } from '../../peach-engine/src/stub-pattern-matcher'
 import type { PackageVersions } from './packageVersionsContract'
 
-function readInstalledVersion(projectRoot: string, name: string): string | null {
+function readInstalledPackage(projectRoot: string, name: string) {
   let dir = projectRoot
   for (;;) {
     let manifest: unknown
@@ -27,11 +28,9 @@ function readInstalledVersion(projectRoot: string, name: string): string | null
       dir = parent
       continue
     }
-    const version =
-      typeof manifest === 'object' && manifest !== null
-        ? Reflect.get(manifest, 'version')
-        : undefined
-    return typeof version === 'string' && version.length > 0 ? version : null
+    return typeof manifest === 'object' && manifest !== null
+      ? { root: path.join(dir, 'node_modules', name), manifest }
+      : null
   }
 }
 
@@ -46,21 +45,62 @@ export function readInstalledPackageVersions(
   }
   const versions: PackageVersions = {}
   for (const name of [...names].sort()) {
-    const version = readInstalledVersion(projectRoot, name)
-    if (version) versions[name] = version
+    const installed = readInstalledPackage(projectRoot, name)
+    const version = installed && Reflect.get(installed.manifest, 'version')
+    if (typeof version === 'string' && version.length > 0) versions[name] = version
   }
   return versions
 }
 
 // plain expo and one servers need no peach plugin. the launcher reads their
-// installed native packages from the same root that autolinking uses.
+// installed native packages from the app's dependency graph. an unrelated
+// package hoisted beside a workspace app is resolvable but is not linked.
 export function readInstalledNativePackageVersions(projectRoot: string): PackageVersions {
+  const appRoot = fs.realpathSync(projectRoot)
+  const nativeNames = new Set<string>()
+  for (const specifier of [
+    'react-native',
+    ...NATIVE_RUNTIME_PACKAGE_NAMES,
+    ...LAZY_STUB_PATTERNS,
+    ...Object.values(COMPAT_STUBS).map((entry) => entry.specifier),
+  ]) {
+    const name = extractPackageFromPath(`node_modules/${specifier}`)
+    if (name) nativeNames.add(name)
+  }
+  const manifest: unknown = JSON.parse(
+    fs.readFileSync(path.join(appRoot, 'package.json'), 'utf8'),
+  )
+  if (typeof manifest !== 'object' || manifest === null) {
+    throw new Error('app package.json must contain an object')
+  }
+  const pending = [{ root: appRoot, manifest }]
+  const visited = new Set<string>()
+  const needed = new Set<string>()
+  for (let next = pending.pop(); next; next = pending.pop()) {
+    const root = fs.realpathSync(next.root)
+    if (visited.has(root)) continue
+    visited.add(root)
+    const fields = ['dependencies', 'optionalDependencies', 'peerDependencies']
+    if (root === appRoot) fields.push('devDependencies')
+    const peers = Reflect.get(next.manifest, 'peerDependenciesMeta')
+    for (const field of fields) {
+      const dependencies = Reflect.get(next.manifest, field)
+      if (typeof dependencies !== 'object' || dependencies === null) continue
+      for (const name of Object.keys(dependencies)) {
+        if (field === 'peerDependencies' && typeof peers === 'object' && peers !== null) {
+          const peer = Reflect.get(peers, name)
+          if (typeof peer === 'object' && peer !== null && Reflect.get(peer, 'optional'))
+            continue
+        }
+        const installed = readInstalledPackage(root, name)
+        if (!installed) continue
+        if (nativeNames.has(name)) needed.add(name)
+        pending.push(installed)
+      }
+    }
+  }
   return readInstalledPackageVersions(
     projectRoot,
-    [
-      'react-native',
-      ...LAZY_STUB_PATTERNS,
-      ...Object.values(COMPAT_STUBS).map((entry) => entry.specifier),
-    ].map((specifier) => `node_modules/${specifier}`),
+    [...needed].map((specifier) => `node_modules/${specifier}`),
   )
 }

package/src/launchMetadataContract.ts

@@ -0,0 +1,24 @@
+// app resources and native configuration travel as a body, never in an http
+// request target. routing and display options remain on the navigable url.
+export const LAUNCH_METADATA_QUERY_PARAM = 'launchMetadata'
+
+export const LAUNCH_METADATA_KEYS: readonly string[] = [
+  'appFonts',
+  'appSplash',
+  'appCatalog',
+  'nativeAppIdentity',
+  'nativeFirebase',
+  'appManifest',
+  'packageVersions',
+  'dotEnv',
+  'env',
+]
+
+export function readLaunchMetadata(wire: string): URLSearchParams {
+  const metadata = new URLSearchParams(wire)
+  const keys: ReadonlySet<string> = new Set(LAUNCH_METADATA_KEYS)
+  for (const key of metadata.keys()) {
+    if (!keys.has(key)) throw new Error(`invalid launch metadata field: ${key}`)
+  }
+  return metadata
+}

package/src/metro-plugin.ts

@@ -12,7 +12,13 @@ import fs from 'fs'
 import { createRequire } from 'module'
 import { randomUUID } from 'node:crypto'
 import path from 'path'
+import {
+  getRuntimePlatformAdapter,
+  isRuntimePlatform,
+} from '../../peach-engine/src/platform/adapter'
 import { resolveAppProject } from '../cli/app-project'
+import { collectAndroidAutolinkedPackages } from './android-autolinking'
+import { insertAndroidAutolinkingFooter } from './androidAutolinkingContract'
 import { tagRnxBundleForPlugin } from './dev-server-open'
 import {
   handleReplacementModuleRequest,
@@ -26,12 +32,11 @@ import {
   toPeachProductionBundleUrl,
   type RNXMetroModuleIdentityMetadata,
 } from './metro-production-bundle'
+import { insertNativeAppIdentityFooter } from './native-app-identity'
 import {
-  canExtractNativeAppIdentity,
-  extractNativeAppIdentityFromFiles,
-  insertNativeAppIdentityFooter,
-} from './native-app-identity'
-import { readNativeAppIdentityFromProject } from './native-app-identity-project'
+  readNativeAppIdentityFromProject,
+  readNativeAppIdentityFromSources,
+} from './native-app-identity-project'
 import { readNativeFirebaseConfig } from './native-firebase-config'
 import {
   insertNativeFirebaseFooter,
@@ -279,7 +284,7 @@ async function appendRNXModulePaths(
 
 export function withPeach<T extends Record<string, unknown>>(
   config: T,
-  options: { iosTarget?: string } = {},
+  options: { iosTarget?: string; androidMergedManifest?: string } = {},
 ): T {
   const cfgProjectRoot = (config as MetroConfigWithServer).projectRoot || process.cwd()
   const cfgWatchFolders = (config as MetroConfigWithServer).watchFolders ?? []
@@ -318,7 +323,14 @@ export function withPeach<T extends Record<string, unknown>>(
           (defaultSerializer ||= createMetroDefaultSerializer(
             serializerOptions.asyncRequireModulePath,
           ))
-        const result = await serializer(entryPoint, preModules, graph, serializerOptions)
+        const bundlePlatform = graph.transformOptions?.platform
+        const [result, androidAutolinkedPackages] = await Promise.all([
+          serializer(entryPoint, preModules, graph, serializerOptions),
+          isRuntimePlatform(bundlePlatform) &&
+          getRuntimePlatformAdapter(bundlePlatform).isAndroid
+            ? collectAndroidAutolinkedPackages(cfgProjectRoot)
+            : Promise.resolve(null),
+        ])
         const staticJson =
           typeof result === 'string' &&
           (serializerOptions.serializerOptions?.output === 'static' ||
@@ -347,46 +359,29 @@ export function withPeach<T extends Record<string, unknown>>(
               'empty-module.js',
             ),
         )
-        const iosRoot = path.join(cfgProjectRoot, 'ios')
-        const bundlePlatform = graph.transformOptions?.platform
-        if (canExtractNativeAppIdentity(bundlePlatform) && fs.existsSync(iosRoot)) {
-          let identity = readNativeAppIdentityFromProject(
+        if (androidAutolinkedPackages !== null) {
+          annotated = await mapMetroSerializerCode(annotated, (code) =>
+            insertAndroidAutolinkingFooter(code, androidAutolinkedPackages),
+          )
+        }
+        const identity =
+          readNativeAppIdentityFromProject(
+            cfgProjectRoot,
+            bundlePlatform,
+            parsePlistSource,
+            options.iosTarget,
+            options.androidMergedManifest,
+          ) ??
+          readNativeAppIdentityFromSources(
             cfgProjectRoot,
             bundlePlatform,
             parsePlistSource,
             options.iosTarget,
           )
-          if (!identity) {
-            const files: Record<string, string> = {}
-            for (const entry of fs.readdirSync(iosRoot, { withFileTypes: true })) {
-              if (entry.name === 'Pods') continue
-              if (entry.isDirectory()) {
-                const names = entry.name.endsWith('.xcodeproj')
-                  ? ['project.pbxproj']
-                  : ['Info.plist', 'AppDelegate.swift', 'AppDelegate.mm', 'AppDelegate.m']
-                for (const name of names) {
-                  const relative = `ios/${entry.name}/${name}`
-                  const file = path.join(cfgProjectRoot, relative)
-                  if (fs.existsSync(file)) files[relative] = fs.readFileSync(file, 'utf8')
-                }
-              } else if (/AppDelegate\.(?:swift|mm|m)$/.test(entry.name)) {
-                const relative = `ios/${entry.name}`
-                const file = path.join(cfgProjectRoot, relative)
-                if (fs.existsSync(file)) files[relative] = fs.readFileSync(file, 'utf8')
-              }
-            }
-            identity = extractNativeAppIdentityFromFiles(
-              files,
-              bundlePlatform,
-              parsePlistSource,
-              options.iosTarget,
-            )
-          }
-          if (identity) {
-            annotated = await mapMetroSerializerCode(annotated, (code) =>
-              insertNativeAppIdentityFooter(code, identity),
-            )
-          }
+        if (identity) {
+          annotated = await mapMetroSerializerCode(annotated, (code) =>
+            insertNativeAppIdentityFooter(code, identity),
+          )
         }
         if (
           [...(graph.dependencies?.values() ?? [])].some((module) =>