vxrn 2.0.0-beta.99.1 → 2.6.1

package/src/utils/createNativeDevEngine.ts

@@ -31,6 +31,7 @@ import { withExpoPublicEnvAliases } from '@vxrn/utils/publicEnv'
 import { DEFAULT_ASSET_EXTS } from '../constants/defaults'
 import { getNativePrelude } from '../runtime/native-prelude'
 import { rnCodegenPlugin } from '../plugins/rnCodegenPlugin'
+import { dedupe } from '../config/getBaseViteConfigOnly'
 
 // Hermes needs the whole class shape lowered *together*. downleveling only the
 // class fields while leaving `class ... extends` as modern ES6 produces a
@@ -124,8 +125,11 @@ function getNativeResolveConfig(platform: 'ios' | 'android') {
     // both here makes a CommonJS require eligible for an export map's ESM
     // `import` target (for example @babel/runtime), which turns callable CJS
     // helpers into namespace objects at runtime.
-    conditionNames: ['react-native'],
-    mainFields: ['react-native', 'module', 'main'],
+    conditionNames: ['react-native', 'browser'],
+    // Native CommonJS consumers need the package's main export shape (punycode
+    // exposes ucs2 there, but only its default export contains it in module).
+    mainFields: ['react-native', 'browser', 'main', 'module'],
+    aliasFields: [['react-native'], ['browser']],
   }
 }
 
@@ -265,22 +269,13 @@ function getNativePlugins(
     serverFileExclusionPlugin(),
     // guard server-only / client-only / web-only / native-only imports
     environmentGuardPlugin(),
+    missingDynamicImportPlugin(),
     // alias RN's Metro HMR client to a no-op; vxrn drives HMR itself (the
     // rolldown-runtime WebSocket); RN's client otherwise opens a /hot socket and
     // red-boxes "unknown-message [object Object]" on every edit (new arch)
     hmrClientNoopPlugin(),
-    // react native 0.87 removed @react-native/assets-registry. libraries like
-    // react-native-svg still import its registry, which is now the same
-    // singleton at react-native/asset-registry. unresolved, rolldown would
-    // leave it as an external import that throws when the module runs.
-    {
-      name: 'vxrn:legacy-asset-registry',
-      resolveId(source, importer) {
-        if (source === '@react-native/assets-registry/registry') {
-          return this.resolve('react-native/asset-registry', importer, { skipSelf: true })
-        }
-      },
-    } satisfies Plugin,
+    nativeIdentityAliasPlugin(platform),
+    nativeAssetRegistryPlugin(root),
     // route every `react-native/*` import through the app's react native copy.
     // two reasons: package managers can install the same react native version at
     // multiple physical paths and rolldown assigns each path its own module
@@ -291,6 +286,7 @@ function getNativePlugins(
     // @react-native/virtualized-lists itself makes — fail resolution against
     // the export map. metro resolves those from the filesystem, so do the same.
     reactNativeDedupePlugin(root),
+    nativePackageDedupePlugin(root),
     // stub CSS imports — native doesn't support CSS and rolldown removed CSS bundling
     cssStubPlugin(),
     // handle import.meta.glob (used by One's route system)
@@ -317,6 +313,8 @@ function getNativePlugins(
     // loops the earlier lowering steps emit.
     hermesLoopsPlugin(sourceMaps),
     ...userPlugins,
+    nativeExportsPrecedencePlugin(root, platform),
+    nativeDeclarationAliasPlugin(root, platform),
   ].map((plugin: Plugin) =>
     plugin.api?.vxrnNative ? plugin.api.vxrnNative(context) : plugin
   )
@@ -445,28 +443,13 @@ export function postProcessNativeBundle(code: string): string {
 }
 
 /**
- * Wrap the dev bundle body in a function scope so module top-level
- * `var`/`function` declarations don't leak onto the global object.
- *
- * rolldown's dev() emits the bundle as a *script*. A top-level `var` in a
- * script creates a NON-configurable property on the global object. RN's
- * `Libraries/Network/fetch.js` declares `var ... Headers, Request, ...`, so
- * `global.Headers`/`global.Request` become non-configurable. RN's `setUpXHR`
- * then calls `polyfillGlobal('Headers', ...)`, whose `polyfillObjectProperty`
- * does `Object.defineProperty(global, 'Headers', { configurable: true, ... })`
- * — which throws "Cannot redefine property" and RN converts to
- * `console.error('Failed to set polyfill. Headers is not configurable.')`.
- * In dev that console.error becomes a blocking LogBox redbox, so the app never
- * mounts (every appium navigation then times out). The prod build is immune:
- * its modules are wrapped in closures (no global leak) and it has no LogBox.
+ * wrap dev module declarations in a function scope. script-level declarations
+ * create global properties that can block react native's lazy polyfills.
+ * production uses rolldown's iife format; the dev engine needs this wrapper.
  *
- * Wrapping everything after the prelude in an IIFE makes those module vars
- * function-scoped, matching prod, so `polyfillGlobal` succeeds. The prelude
- * stays at script scope because it intentionally installs globals
- * (`globalThis.global`/`__DEV__`/`process`/...). Intentional globals survive:
- * the runtime is assigned via `globalThis.__rolldown_runtime__ = ...`, and HMR
- * updates run through a *direct* `eval` inside this scope, so they still see
- * the closure's `__esmMin`/`__toCommonJS`/module bindings.
+ * keep the prelude at script scope because it installs intentional globals.
+ * the dev runtime assigns itself to globalThis, and hmr's direct eval stays
+ * inside this closure so it can reach module bindings and runtime helpers.
  */
 export function wrapNativeBundleModuleScope(code: string): string {
   // the prelude (intro) ends right before the rolldown runtime region
@@ -584,7 +567,6 @@ export async function createNativeDevEngine(
   let bundleReject: ((error: Error) => void) | null = null
   let bundlePromise: Promise<NativeDevBundle> | null = null
 
-  const resolvedHost = host === '0.0.0.0' ? 'localhost' : host
   const virtualEntry = nativeVirtualEntryPlugin(root, {
     dev: true,
     platform,
@@ -657,11 +639,15 @@ export async function createNativeDevEngine(
     // only polyfilled once InitializeCore has run) and hand it to the runtime,
     // which owns every message it carries. handed over immediately rather than
     // from an open handler: a host that does not honor `socket.onopen = fn`
-    // would otherwise silently never get Fast Refresh.
+    // would otherwise silently never get Fast Refresh. the socket goes to the
+    // origin the device loaded this bundle from (RN's getDevServer), never the
+    // server's own host:port: an emulator behind `adb reverse tcp:8081 tcp:<port>`
+    // or a phone on the LAN cannot reach the server's localhost:<port>.
     outro: `
 try {
   var __WS = (init_WebSocket(), __toCommonJS(WebSocket_exports)).default;
-  var __hmrUrl = 'ws://${resolvedHost}:${port}/hot?platform=${platform}&clientId=' + encodeURIComponent(__rolldown_runtime__.clientId);
+  var __devServer = (init_getDevServer(), __toCommonJS(getDevServer_exports)).default();
+  var __hmrUrl = __devServer.url.replace(/^http/, 'ws') + 'hot?platform=${platform}&clientId=' + encodeURIComponent(__rolldown_runtime__.clientId);
   __rolldown_runtime__.setup(new __WS(__hmrUrl));
 } catch(e) {
   // a swallowed failure here leaves the app permanently without Fast Refresh and
@@ -960,7 +946,11 @@ export async function buildNativeBundle(
       // last, so it sees what every other plugin produced
       nativeBundlePostProcessPlugin(),
     ],
-    output: getNativeOutputOptions(prelude, sourcemap, minify),
+    output: {
+      ...getNativeOutputOptions(prelude, sourcemap, minify),
+      // native hosts evaluate a script; module bindings must stay out of globals.
+      format: 'iife',
+    },
   })
   const chunk = result.output.find((o) => o.type === 'chunk' && o.isEntry)
 
@@ -1132,16 +1122,18 @@ ${routeHmr}
       routes.files = files
       if (!useDynamicRouteRegistry) return
 
+      mkdirSync(dirname(registryPath), { recursive: true })
+      // rolldown resolves the registry through symlinked node_modules before its imports.
+      const registryDir = realpathSync(dirname(registryPath))
       const source = `export const routes = {\n${[...files]
         .sort()
         .map((file) => {
           const routeKey = `/${normalizePath(relative(root, file))}`
-          let importPath = normalizePath(relative(dirname(registryPath), file))
+          let importPath = normalizePath(relative(registryDir, file))
           if (!importPath.startsWith('.')) importPath = `./${importPath}`
           return `  ${JSON.stringify(routeKey)}: () => import(${JSON.stringify(importPath)})`
         })
         .join(',\n')}\n}\n`
-      mkdirSync(dirname(registryPath), { recursive: true })
       if (!existsSync(registryPath) || readFileSync(registryPath, 'utf8') !== source) {
         writeFileSync(registryPath, source)
       }
@@ -1243,6 +1235,36 @@ function serverFileExclusionPlugin(): Plugin {
   }
 }
 
+/**
+ * An `import()` of a package that is not installed stays a raw dynamic import
+ * in the bundle, which Hermes cannot parse. Metro resolves it as an optional
+ * dependency: the import rejects with "Cannot find module" when it runs. Do the
+ * same, so a library that probes an optional peer (`await import('x')` inside
+ * try) builds and falls back at runtime.
+ */
+function missingDynamicImportPlugin(): Plugin {
+  const PREFIX = '\0vxrn-missing-module:'
+  return {
+    name: 'vxrn:missing-dynamic-import',
+    async resolveId(source, importer, options) {
+      if (options.kind !== 'dynamic-import') return
+      if (source.startsWith('.') || source.startsWith('/') || source.includes(':')) return
+      if (source.startsWith('\0')) return
+      const resolved = await this.resolve(source, importer, {
+        skipSelf: true,
+        kind: options.kind,
+      })
+      if (resolved) return resolved
+      return { id: `${PREFIX}${source}`, external: false }
+    },
+    load(id) {
+      if (!id.startsWith(PREFIX)) return
+      const source = JSON.stringify(`Cannot find module '${id.slice(PREFIX.length)}'`)
+      return { code: `throw new Error(${source});`, moduleType: 'js' as any }
+    },
+  }
+}
+
 /**
  * Guard environment-specific bare imports in native bundles.
  * - server-only, client-only, web-only → throw at runtime
@@ -1315,6 +1337,203 @@ export function hmrClientNoopPlugin(): Plugin {
   }
 }
 
+function nativeIdentityAliasPlugin(platform: 'ios' | 'android'): Plugin {
+  const packages = new Map<
+    string,
+    { root: string; aliases: Record<string, unknown> } | null
+  >()
+  let resolver: import('rolldown/experimental').ResolverFactory | undefined
+  const findPackage = (
+    directory: string
+  ): { root: string; aliases: Record<string, unknown> } | null => {
+    if (packages.has(directory)) return packages.get(directory)!
+    let result: { root: string; aliases: Record<string, unknown> } | null = null
+    const manifest = join(directory, 'package.json')
+    if (existsSync(manifest)) {
+      try {
+        const field = JSON.parse(readFileSync(manifest, 'utf8'))['react-native']
+        result = {
+          root: directory,
+          aliases: field && typeof field === 'object' ? field : {},
+        }
+      } catch {}
+    } else {
+      const parent = dirname(directory)
+      if (parent !== directory) result = findPackage(parent)
+    }
+    packages.set(directory, result)
+    return result
+  }
+  return {
+    name: 'vxrn:native-identity-alias',
+    async resolveId(source, importer) {
+      if (!importer || !source.startsWith('.')) return
+      const pkg = findPackage(dirname(importer))
+      if (!pkg) return
+      const key = `./${normalizePath(relative(pkg.root, resolve(dirname(importer), source)))}`
+      if (pkg.aliases[key] !== key) return
+      // A native identity mapping deliberately keeps the original implementation
+      // even when the browser field maps it elsewhere. Avoid alias recursion.
+      if (!resolver) {
+        const { ResolverFactory } = await import('rolldown/experimental')
+        resolver = new ResolverFactory({
+          ...getNativeResolveConfig(platform),
+          aliasFields: [],
+        })
+      }
+      const result = resolver.sync(dirname(importer), source)
+      if (result.path) return result.path
+    },
+  }
+}
+
+// export maps resolve in key order, so a package listing `browser` before
+// `react-native` would give native its web build. the browser fallback is for
+// packages without a native target: where a package's exports name both,
+// resolve it as metro does, without `browser`.
+function nativeExportsPrecedencePlugin(
+  root: string,
+  platform: 'ios' | 'android'
+): Plugin {
+  const manifests = new Map<string, { name?: string; exports?: unknown } | null>()
+  const readManifest = (directory: string) => {
+    if (!manifests.has(directory)) {
+      let manifest = null
+      try {
+        manifest = JSON.parse(readFileSync(join(directory, 'package.json'), 'utf8'))
+      } catch {}
+      manifests.set(directory, manifest)
+    }
+    return manifests.get(directory)
+  }
+  const resolvers = new Map<string, import('rolldown/experimental').ResolverFactory>()
+  return {
+    name: 'vxrn:native-exports-precedence',
+    async resolveId(source, importer, options) {
+      if (source.startsWith('.') || source.startsWith('/') || source.includes(':')) return
+      const resolved = await this.resolve(source, importer, {
+        skipSelf: true,
+        kind: options.kind,
+      })
+      if (!resolved || resolved.external || resolved.id.startsWith('\0')) return resolved
+      const name = source
+        .split('/')
+        .slice(0, source.startsWith('@') ? 2 : 1)
+        .join('/')
+      let directory = dirname(resolved.id)
+      while (readManifest(directory)?.name !== name) {
+        if (dirname(directory) === directory) return resolved
+        directory = dirname(directory)
+      }
+      const exportsMap = JSON.stringify(readManifest(directory)?.exports ?? null)
+      if (!exportsMap.includes('"react-native"') || !exportsMap.includes('"browser"')) {
+        return resolved
+      }
+      const kind = options.kind === 'require-call' ? 'require' : 'import'
+      let resolver = resolvers.get(kind)
+      if (!resolver) {
+        const { ResolverFactory } = await import('rolldown/experimental')
+        resolver = new ResolverFactory({
+          ...getNativeResolveConfig(platform),
+          conditionNames: ['react-native', kind, 'default'],
+        })
+        resolvers.set(kind, resolver)
+      }
+      const native = resolver.sync(importer ? dirname(importer) : root, source)
+      if (!native.path || native.path === resolved.id) return resolved
+      return this.resolve(native.path, importer, { skipSelf: true, kind: options.kind })
+    },
+  }
+}
+
+function nativeDeclarationAliasPlugin(root: string, platform: 'ios' | 'android'): Plugin {
+  const resolvers = new Map<string, import('rolldown/experimental').ResolverFactory>()
+  return {
+    name: 'vxrn:declaration-alias',
+    async resolveId(source, importer, options) {
+      if (source.startsWith('.') || source.startsWith('/') || source.includes(':')) return
+      const resolved = await this.resolve(source, importer, {
+        skipSelf: true,
+        kind: options.kind,
+      })
+      if (!resolved || resolved.external || !/\.d\.[cm]?ts$/.test(resolved.id)) {
+        return resolved
+      }
+      // tsconfig paths can supply types for a package without replacing its
+      // runtime export. Resolve that package with the same native conditions,
+      // but without the declaration alias, and preserve import/require selection.
+      const kind = options.kind === 'require-call' ? 'require' : 'import'
+      let resolver = resolvers.get(kind)
+      if (!resolver) {
+        const { ResolverFactory } = await import('rolldown/experimental')
+        resolver = new ResolverFactory({
+          ...getNativeResolveConfig(platform),
+          conditionNames: ['react-native', 'browser', kind, 'default'],
+        })
+        resolvers.set(kind, resolver)
+      }
+      const runtime = resolver.sync(importer ? dirname(importer) : root, source)
+      if (!runtime.path || /\.d\.[cm]?ts$/.test(runtime.path)) {
+        this.error(
+          `Native import ${source} resolves to a declaration without a runtime export`
+        )
+      }
+      return this.resolve(runtime.path, importer, { skipSelf: true, kind: options.kind })
+    },
+  }
+}
+
+function nativeAssetRegistryPlugin(root: string): Plugin {
+  let registryPath: string | null | undefined
+  return {
+    name: 'vxrn:asset-registry',
+    async resolveId(source, importer) {
+      if (
+        source !== 'react-native/asset-registry' &&
+        source !== '@react-native/assets-registry/registry'
+      ) {
+        return
+      }
+      if (registryPath === undefined) {
+        try {
+          const reactNativeRoot = dirname(resolvePath('react-native/package.json', root))
+          // RN 0.87 moved the singleton into RN and exports this file as
+          // react-native/asset-registry. Older RN versions own it in a package.
+          const exportedRegistry = join(reactNativeRoot, 'src/asset-registry.js')
+          registryPath = existsSync(exportedRegistry)
+            ? exportedRegistry
+            : resolvePath('@react-native/assets-registry/registry', reactNativeRoot)
+        } catch {
+          registryPath = null
+        }
+      }
+      if (registryPath) {
+        return this.resolve(normalizePath(registryPath), importer, { skipSelf: true })
+      }
+    },
+  }
+}
+
+function nativePackageDedupePlugin(root: string): Plugin {
+  // these packages share one native runtime; nested copies cannot initialize it twice.
+  const packages = new Set([
+    ...dedupe,
+    'react-native-worklets',
+    'react-native-nitro-modules',
+  ])
+  return {
+    name: 'vxrn:native-package-dedupe',
+    async resolveId(source) {
+      const parts = source.split('/')
+      const packageName = source.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0]
+      if (!packages.has(packageName)) return
+      // use the app's package copy for contexts and subpaths, preserving the
+      // native export conditions selected by rolldown.
+      return this.resolve(source, join(root, 'package.json'), { skipSelf: true })
+    },
+  }
+}
+
 function reactNativeDedupePlugin(root: string): Plugin {
   // package managers can install the same react native version at multiple
   // physical paths. rolldown assigns each path a module identity, so resolving
@@ -1928,7 +2147,7 @@ function copyNativeAssetFiles(
 
 /**
  * SWC transform for Hermes compatibility.
- * Transforms class properties and private fields that Hermes doesn't support.
+ * Lowers classes, lexical bindings, and async syntax for legacy Hermes.
  * Inspired by rollipop's swc-plugin.ts.
  */
 export function hermesCompatSWCPlugin(dev: boolean, sourceMaps = false): Plugin {
@@ -1940,14 +2159,14 @@ export function hermesCompatSWCPlugin(dev: boolean, sourceMaps = false): Plugin
       if (!/\.[cm]?[jt]sx?$/.test(id)) return
       if (id.includes('\0') || id.includes('virtual:')) return
       // skip files that don't need transformation
-      const hasClass = code.includes('class ') || code.includes('class{')
+      const hasClass = /\bclass(?:\s|\{)/.test(code)
       const hasAsync = code.includes('async')
-      const hasBlockScopedLoop = /\bfor\s*\(\s*(?:const|let)\b/.test(code)
-      if (!hasClass && !hasAsync && !hasBlockScopedLoop) return
+      const hasBlockScopedBinding = /\b(?:const|let)\s/.test(code)
+      if (!hasClass && !hasAsync && !hasBlockScopedBinding) return
       let output: { code: string; map?: any } | undefined
-      // keep the existing oxc limit for large prebuilt files. async lowering
-      // below has no size exemption and runs after the worklet transform.
-      if (code.length <= 500_000) {
+      // Keep the Oxc limit for other large prebuilt files. Class, lexical binding,
+      // and async lowering below have no size exemption for legacy Hermes.
+      if (code.length <= 500_000 || hasClass) {
         if (!oxc) oxc = await import('oxc-transform')
         const lang = /\.[cm]?ts$/.test(id) ? 'ts' : id.endsWith('.tsx') ? 'tsx' : 'jsx'
         const result = oxc.transformSync(id, code, {
@@ -1967,6 +2186,17 @@ export function hermesCompatSWCPlugin(dev: boolean, sourceMaps = false): Plugin
           map: sourceMaps ? result.map : undefined,
         }
       }
+      if (hasClass || hasBlockScopedBinding) {
+        const { transformHermesClasses } = await import('@vxrn/compiler')
+        const classes = await transformHermesClasses(output?.code ?? code, id, sourceMaps)
+        if (classes) {
+          if (classes.map && output?.map) {
+            const remapping = (await import('@jridgewell/remapping')).default
+            classes.map = remapping([classes.map, output.map], () => null)
+          }
+          output = classes
+        }
+      }
       const lowered = await transformHermesAsync(output?.code ?? code, id, sourceMaps)
       if (!lowered) return output
       if (lowered.map && output?.map) {

package/src/utils/nativeRun.test.ts

@@ -1,4 +1,4 @@
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { createServer } from 'node:http'
 import { dirname, join } from 'node:path'
@@ -17,6 +17,49 @@ vi.mock('../utils/patches', () => ({
 const here = dirname(fileURLToPath(import.meta.url))
 const workspaceRoot = join(here, '..', '..', '..')
 
+// an android sdk whose adb reports exactly these connected serials
+function fakeAndroidSdk(serials: string[]) {
+  const sdk = mkdtempSync(join(tmpdir(), 'nativerun-sdk-'))
+  mkdirSync(join(sdk, 'platform-tools'))
+  const listing = ['List of devices attached', ...serials.map((serial) => `${serial}\tdevice`)]
+  writeFileSync(
+    join(sdk, 'platform-tools', 'adb'),
+    `#!/bin/sh\nprintf '%s\\n' ${listing.map((line) => `'${line}'`).join(' ')}\n`
+  )
+  chmodSync(join(sdk, 'platform-tools', 'adb'), 0o755)
+  return sdk
+}
+
+async function withAndroidSdk<T>(serials: string[], serial: string | undefined, run: () => Promise<T>) {
+  const sdk = fakeAndroidSdk(serials)
+  const previous = { home: process.env.ANDROID_HOME, serial: process.env.ANDROID_SERIAL }
+  process.env.ANDROID_HOME = sdk
+  if (serial) process.env.ANDROID_SERIAL = serial
+  else delete process.env.ANDROID_SERIAL
+  try {
+    return await run()
+  } finally {
+    if (previous.home === undefined) delete process.env.ANDROID_HOME
+    else process.env.ANDROID_HOME = previous.home
+    if (previous.serial === undefined) delete process.env.ANDROID_SERIAL
+    else process.env.ANDROID_SERIAL = previous.serial
+    rmSync(sdk, { recursive: true, force: true })
+  }
+}
+
+async function withDevServer<T>(run: (port: number) => Promise<T>) {
+  const server = createServer((req, res) => {
+    res.end(req.url === '/status' ? 'packager-status:running' : 'ok')
+  })
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve))
+  const address = server.address()
+  try {
+    return await run(typeof address === 'object' && address ? address.port : 0)
+  } finally {
+    server.close()
+  }
+}
+
 describe('expo-free run commands', () => {
   it('delegates build/install/launch to community cli with no packager', () => {
     expect(buildNativeRunCommand({ platform: 'ios', port: 8082 })).toEqual({
@@ -32,22 +75,34 @@ describe('expo-free run commands', () => {
   })
 
   it('forwards an explicit simulator target instead of letting the cli pick', () => {
-    expect(
-      buildNativeRunCommand({ platform: 'ios', simulator: 'iPhone 16' })
-    ).toEqual({
+    expect(buildNativeRunCommand({ platform: 'ios', simulator: 'iPhone 16' })).toEqual({
       command: 'run-ios',
       argv: ['--no-packager', '--port', '8081', '--simulator', 'iPhone 16'],
       port: 8081,
     })
-    expect(
-      buildNativeRunCommand({ platform: 'ios', udid: 'some-udid' })
-    ).toEqual({
+    expect(buildNativeRunCommand({ platform: 'ios', udid: 'some-udid' })).toEqual({
       command: 'run-ios',
       argv: ['--no-packager', '--port', '8081', '--udid', 'some-udid'],
       port: 8081,
     })
   })
 
+  it('targets the selected Android device rather than launching on every emulator', () => {
+    vi.stubEnv('ANDROID_SERIAL', 'emulator-5582')
+    try {
+      expect(buildNativeRunCommand({ platform: 'android', port: 8097 }).argv).toEqual([
+        '--no-packager',
+        '--port',
+        '8097',
+        '--device',
+        'emulator-5582',
+      ])
+      expect(buildNativeRunCommand({ platform: 'ios' }).argv).not.toContain('--device')
+    } finally {
+      vi.unstubAllEnvs()
+    }
+  })
+
   it('never resolves the expo cli', () => {
     const source = readFileSync(join(here, 'nativeRun.ts'), 'utf8')
     expect(source).not.toContain('expo/cli')
@@ -65,9 +120,10 @@ describe('expo-free run commands', () => {
     const port = typeof address === 'object' && address ? address.port : 0
     const calls: Array<{ executable: string; argv: string[] }> = []
     const previousMetroPort = process.env.RCT_METRO_PORT
+    const root = mkdtempSync(join(tmpdir(), 'vxrn-run-no-app-cli-'))
     try {
       await nativeRun({
-        root: workspaceRoot,
+        root,
         platform: 'ios',
         port,
         spawn: (executable, argv) => {
@@ -84,6 +140,7 @@ describe('expo-free run commands', () => {
       if (previousMetroPort === undefined) delete process.env.RCT_METRO_PORT
       else process.env.RCT_METRO_PORT = previousMetroPort
       server.close()
+      rmSync(root, { recursive: true, force: true })
     }
   })
 
@@ -101,18 +158,20 @@ describe('expo-free run commands', () => {
     )
 
     try {
-      const launch = nativeRun({
-        root: workspaceRoot,
-        platform: 'android',
-        port,
-        spawn: (_executable, argv) => calls.push(argv),
-      })
-      await new Promise<void>((resolve) => setImmediate(resolve))
-      expect(calls).toHaveLength(0)
+      await withAndroidSdk(['emulator-5554'], undefined, async () => {
+        const launch = nativeRun({
+          root: workspaceRoot,
+          platform: 'android',
+          port,
+          spawn: (_executable, argv) => calls.push(argv),
+        })
+        await new Promise<void>((resolve) => setImmediate(resolve))
+        expect(calls).toHaveLength(0)
 
-      finishPatches?.()
-      await launch
-      expect(calls).toHaveLength(1)
+        finishPatches?.()
+        await launch
+        expect(calls).toHaveLength(1)
+      })
     } finally {
       server.close()
     }
@@ -141,14 +200,17 @@ describe('expo-free run commands', () => {
     }
   })
 
-  it('resolves the ios bundle id from app.json', () => {
+  it('resolves the ios bundle id from the prebuilt ios project', () => {
     const dir = mkdtempSync(join(tmpdir(), 'nativerun-'))
     try {
       expect(resolveIosBundleId(dir)).toBeNull()
-      writeFileSync(join(dir, 'app.json'), JSON.stringify({ expo: { ios: { bundleIdentifier: 'dev.example.app' } } }))
-      expect(resolveIosBundleId(dir)).toBe('dev.example.app')
-      writeFileSync(join(dir, 'app.json'), 'not json')
+      mkdirSync(join(dir, 'ios', 'Example.xcodeproj'), { recursive: true })
       expect(resolveIosBundleId(dir)).toBeNull()
+      writeFileSync(
+        join(dir, 'ios', 'Example.xcodeproj', 'project.pbxproj'),
+        'buildSettings = {\n\t\t\t\tPRODUCT_BUNDLE_IDENTIFIER = dev.example.app;\n\t\t\t};'
+      )
+      expect(resolveIosBundleId(dir)).toBe('dev.example.app')
     } finally {
       rmSync(dir, { recursive: true, force: true })
     }
@@ -166,4 +228,44 @@ describe('expo-free run commands', () => {
       })
     ).rejects.toThrow(/No dev server running/)
   })
+
+  it('fails before launching when no android device is connected', async () => {
+    const spawn = vi.fn()
+    await withDevServer((port) =>
+      withAndroidSdk([], undefined, () =>
+        expect(
+          nativeRun({ root: workspaceRoot, platform: 'android', port, spawn })
+        ).rejects.toThrow(/No Android device or emulator is connected/)
+      )
+    )
+    expect(spawn).not.toHaveBeenCalled()
+  })
+
+  it('fails before launching when the chosen android serial is not connected', async () => {
+    const spawn = vi.fn()
+    await withDevServer((port) =>
+      withAndroidSdk(['emulator-5554'], 'emulator-5556', () =>
+        expect(
+          nativeRun({ root: workspaceRoot, platform: 'android', port, spawn })
+        ).rejects.toThrow(/emulator-5556 is not connected \(connected: emulator-5554\)/)
+      )
+    )
+    expect(spawn).not.toHaveBeenCalled()
+  })
+
+  it('launches on the chosen android serial when it is connected', async () => {
+    const calls: string[][] = []
+    await withDevServer((port) =>
+      withAndroidSdk(['emulator-5554', 'emulator-5556'], 'emulator-5556', () =>
+        nativeRun({
+          root: workspaceRoot,
+          platform: 'android',
+          port,
+          spawn: (_executable, argv) => calls.push(argv),
+        })
+      )
+    )
+    expect(calls).toHaveLength(1)
+    expect(calls[0]).toEqual(expect.arrayContaining(['--device', 'emulator-5556']))
+  })
 })