@vxrn/vite-plugin-metro 2.0.0-beta.33.1 → 2.0.0-beta.362.1

package/src/metro-config/getMetroConfigFromViteConfig.ts

@@ -1,36 +1,85 @@
-import type { ResolvedConfig } from 'vite'
+import { searchForWorkspaceRoot, type ResolvedConfig } from 'vite'
 import { spawn } from 'node:child_process'
 import { resolve } from 'node:path'
 import micromatch from 'micromatch'
+import { getDefaultConfig } from '@react-native/metro-config'
 
-// For Metro and Expo, we only import types here.
-// We use `projectImport` to dynamically import the actual modules
-// at runtime to ensure they are loaded from the user's project root.
+// metro itself is loaded from the app so its cli and config stay aligned.
+// the base config belongs to this package and matches its react-native peer.
 import type { loadConfig as loadConfigT } from 'metro'
-import type { getDefaultConfig as getDefaultConfigT } from '@expo/metro-config'
 
+import { findUserBabelConfig } from '@vxrn/compiler'
 import { projectImport, projectResolve } from '../utils/projectImport'
 import { getTerminalReporter } from '../utils/getTerminalReporter'
-import { patchExpoGoManifestHandlerMiddlewareWithCustomMainModuleName } from '../utils/patchExpoGoManifestHandlerMiddlewareWithCustomMainModuleName'
 import type { MetroPluginOptions } from '../plugins/metroPlugin'
 import type { ExtraConfig, MetroConfigExtended } from './types'
 
-type MetroInputConfig = Parameters<typeof loadConfigT>[1]
+type MetroInputConfig = NonNullable<Parameters<typeof loadConfigT>[1]>
 
 const WATCHMAN_PROBE_TIMEOUT_MS = 2000
+const expoEnvAdditionalExts = ['env', 'local', 'development']
+// keep js before mjs so platform-aware .native.js wins for one dist.
+const metroSourceExts = ['js', 'jsx', 'json', 'ts', 'tsx', 'mjs', 'cjs', 'swift', 'kt']
 const watchmanResponsivePromises = new Map<string, Promise<boolean>>()
 let didWarnAboutWatchmanFallback = false
 const rootIndexBundleRequestPattern = /^(https?:\/\/[^/]+)?\/index\.bundle(?=$|[?#])/
+// expo prebuild writes an AppDelegate (ios) and MainApplication (android) whose
+// debug bundle url is `.expo/.virtual-metro-entry`. expo maps it to the main
+// entry through server.rewriteRequestUrl (see @expo/metro-config
+// src/rewriteRequestUrl.ts: `url.includes('/.expo/.virtual-metro-entry.bundle?')`
+// rewrites to the resolved entry, preserving relative vs absolute shape and
+// query). match that path to the same main entry as index.
+const expoVirtualEntryBundleRequestPattern =
+  /^(https?:\/\/[^/]+)?\/\.expo\/\.virtual-metro-entry\.bundle(?=$|[?#])/
 // keep app build output and volatile caches out of Metro's fallback watcher.
-// package dist directories remain visible because Metro resolves modules from them.
+// package dist directories remain visible because Metro resolves modules from
+// them, including a dependency's own dist/server, so the app build output
+// pattern never matches inside node_modules.
 const metroWatchExclusions = [
-  /[/\\]dist[/\\](?:static|server)(?:[/\\]|$)/,
+  /^(?!.*[/\\]node_modules[/\\]).*[/\\]dist[/\\](?:static|server)(?:[/\\]|$)/,
   /[/\\]tests[/\\][^/\\]+[/\\]dist(?:[/\\]|$)/,
   /[/\\]\.docker(?:[/\\]|$)/,
   /[/\\]\.vite(?:[/\\]|$)/,
   /[/\\]node_modules[/\\]\.vxrn(?:[/\\]|$)/,
 ]
 
+function enforceWorkspaceVisibility(
+  config: MetroInputConfig,
+  projectRoot: string
+): MetroInputConfig {
+  const workspaceRoot = searchForWorkspaceRoot(projectRoot)
+  if (workspaceRoot === projectRoot) return config
+
+  return {
+    ...config,
+    watchFolders: [...new Set([...(config.watchFolders ?? []), workspaceRoot])],
+    resolver: {
+      ...config.resolver,
+      nodeModulesPaths: [
+        ...new Set([
+          ...(config.resolver?.nodeModulesPaths ?? []),
+          resolve(projectRoot, 'node_modules'),
+          resolve(workspaceRoot, 'node_modules'),
+        ]),
+      ],
+    },
+  }
+}
+
+function getReactNativeDefaultConfig(projectRoot: string): MetroInputConfig {
+  const config = enforceWorkspaceVisibility(
+    getDefaultConfig(projectRoot) as MetroInputConfig,
+    projectRoot
+  )
+  return {
+    ...config,
+    resolver: {
+      ...config.resolver,
+      assetExts: [...new Set([...(config.resolver?.assetExts ?? []), 'glb'])],
+    },
+  }
+}
+
 function getPlatformFromBundleUrl(url: string): 'ios' | 'android' {
   const platform = url.match(/[?&]platform=(ios|android)(?:&|$)/)?.[1]
   return platform === 'android' ? 'android' : 'ios'
@@ -44,11 +93,76 @@ function rewriteMainModuleBundleUrl(
     platform: getPlatformFromBundleUrl(url),
   })
 
-  if (url.includes('/.expo/.virtual-metro-entry.bundle?')) {
-    return url.replace('.expo/.virtual-metro-entry', resolvedMainModulePath)
+  if (rootIndexBundleRequestPattern.test(url)) {
+    return url.replace(
+      rootIndexBundleRequestPattern,
+      `$1/${resolvedMainModulePath}.bundle`
+    )
   }
+  return url.replace(
+    expoVirtualEntryBundleRequestPattern,
+    `$1/${resolvedMainModulePath}.bundle`
+  )
+}
 
-  return url.replace(rootIndexBundleRequestPattern, `$1/${resolvedMainModulePath}.bundle`)
+function isMainModuleBundleRequest(url: string) {
+  return (
+    rootIndexBundleRequestPattern.test(url) ||
+    expoVirtualEntryBundleRequestPattern.test(url)
+  )
+}
+
+function isBareSpecifier(name: string) {
+  return name !== '' && !name.startsWith('.') && !name.startsWith('/')
+}
+
+// metro parses `/one/metro-entry.bundle` to the entry `./one/metro-entry`
+// relative to the server root, which misses node_modules package lookup.
+function bareMainModuleForRequest(
+  moduleName: string,
+  mainModuleName: string | undefined
+) {
+  if (!mainModuleName || !isBareSpecifier(mainModuleName)) return undefined
+  if (moduleName === `./${mainModuleName}`) return mainModuleName
+  return undefined
+}
+
+// defaultConfigOverrides and Metro config loading can replace the resolver.
+// enforce entry and vite dedupe semantics on the final resolver while
+// preserving its platform, export conditions and custom resolution policy.
+function enforcePackageResolution(
+  config: MetroInputConfig,
+  mainModuleName: string | undefined,
+  dedupe: readonly string[],
+  projectRoot: string
+): MetroInputConfig {
+  const dedupedPackages = new Set(dedupe)
+  if ((!mainModuleName || !isBareSpecifier(mainModuleName)) && !dedupedPackages.size) {
+    return config
+  }
+  const rootOrigin = resolve(projectRoot, 'package.json')
+  const innerResolveRequest = config.resolver?.resolveRequest
+  return {
+    ...config,
+    resolver: {
+      ...config.resolver,
+      resolveRequest: (context, moduleName, platform) => {
+        const bareMain = bareMainModuleForRequest(moduleName, mainModuleName)
+        const request = bareMain ?? moduleName
+        const packageEnd = request.indexOf(
+          '/',
+          request.startsWith('@') ? request.indexOf('/') + 1 : 0
+        )
+        const packageName = packageEnd === -1 ? request : request.slice(0, packageEnd)
+        const resolutionContext =
+          isBareSpecifier(request) && dedupedPackages.has(packageName)
+            ? { ...context, originModulePath: rootOrigin }
+            : context
+        const resolveRequest = innerResolveRequest || context.resolveRequest
+        return resolveRequest(resolutionContext, request, platform)
+      },
+    },
+  }
 }
 
 async function isWatchmanResponsive(projectRoot: string) {
@@ -89,11 +203,52 @@ async function isWatchmanResponsive(projectRoot: string) {
   return probe
 }
 
+/**
+ * Decides whether Metro runs the native worker or the babel transformer.
+ * No babel by default: the worker throws on a babel plugin it has no port
+ * for, so opting back in is explicit rather than something you drift into.
+ * When a user adds a custom babel config, respect it rather than forcing
+ * native transforms, unless explicitly overridden. Shared by both config
+ * builders so the two never drift apart.
+ */
+function resolveNativeTransforms(
+  projectRoot: string,
+  metroPluginOptions: MetroPluginOptions
+): { isNativeTransforms: boolean; userBabelConfigPath: string | null } {
+  const userBabelConfigPath = projectRoot ? findUserBabelConfig(projectRoot) : null
+  const hasUserBabelConfig = Boolean(userBabelConfigPath)
+
+  const isNativeTransforms =
+    process.env.ONE_METRO_NATIVE_TRANSFORMS === '0'
+      ? false
+      : process.env.ONE_METRO_NATIVE_TRANSFORMS === '1'
+        ? true
+        : metroPluginOptions.nativeTransforms === false
+          ? false
+          : metroPluginOptions.nativeTransforms === true
+            ? true
+            : hasUserBabelConfig
+              ? false
+              : true
+
+  // the native worker runs no babel at all, so reaching it here means an
+  // explicit override is about to silently drop the user's plugins. name the
+  // ignored file rather than swallowing it.
+  if (userBabelConfigPath && isNativeTransforms) {
+    console.warn(
+      `[vxrn/metro] Ignoring user babel config at ${userBabelConfigPath} because native transforms are explicitly enabled (nativeTransforms: true or ONE_METRO_NATIVE_TRANSFORMS=1). ` +
+        `Port its plugins to nativeTransformModules, or set nativeTransforms: false (or ONE_METRO_NATIVE_TRANSFORMS=0) to use the babel transformer.`
+    )
+  }
+
+  return { isNativeTransforms, userBabelConfigPath }
+}
+
 /**
  * Build the Metro config input WITHOUT calling Metro's `loadConfig`. Returns
  * the same shape Metro `loadConfig` expects as its second argument. Use this
  * from a project's `metro.config.cjs` so the outer `loadConfig` (driven by
- * Expo CLI / Metro CLI) is the only one that runs — avoids infinite
+ * the Metro CLI) is the only one that runs. this avoids infinite
  * recursion that would happen if the inner pipeline also called `loadConfig`
  * and re-read the same metro.config.cjs.
  */
@@ -114,53 +269,20 @@ export async function buildMetroConfigInputFromViteConfig(
     )
   }
 
-  const { getDefaultConfig } = await projectImport<{
-    getDefaultConfig: typeof getDefaultConfigT
-  }>(projectRoot, '@expo/metro-config')
-
-  const _defaultConfig: MetroInputConfig = getDefaultConfig(projectRoot) as any
+  const _defaultConfig = getReactNativeDefaultConfig(projectRoot)
 
   if (mainModuleName) {
-    const origRewriteRequestUrl = _defaultConfig!.server!.rewriteRequestUrl!
-
-    const resolveMainModuleName: (p: { platform: 'ios' | 'android' }) => string =
-      await (async () => {
-        const ExpoGoManifestHandlerMiddleware = (
-          await projectImport(
-            projectRoot,
-            '@expo/cli/build/src/start/server/middleware/ExpoGoManifestHandlerMiddleware.js'
-          )
-        ).default.ExpoGoManifestHandlerMiddleware
-
-        const manifestHandlerMiddleware = new ExpoGoManifestHandlerMiddleware(
-          projectRoot,
-          {}
-        )
-
-        patchExpoGoManifestHandlerMiddlewareWithCustomMainModuleName(
-          manifestHandlerMiddleware,
-          mainModuleName
-        )
-
-        return (p) => {
-          return manifestHandlerMiddleware.resolveMainModuleName({
-            pkg: { main: mainModuleName },
-            platform: p.platform,
-          })
-        }
-      })()
+    const origRewriteRequestUrl = _defaultConfig!.server?.rewriteRequestUrl
+    const resolveMainModuleName = () => mainModuleName
 
     extraConfig.getResolveMainModuleName = resolveMainModuleName
 
     // @ts-expect-error Metro 0.83 made this read-only in types but we need to patch it
     _defaultConfig!.server!.rewriteRequestUrl = (url) => {
-      if (
-        url.includes('/.expo/.virtual-metro-entry.bundle?') ||
-        rootIndexBundleRequestPattern.test(url)
-      ) {
+      if (isMainModuleBundleRequest(url)) {
         return rewriteMainModuleBundleUrl(url, resolveMainModuleName)
       }
-      return origRewriteRequestUrl(url)
+      return origRewriteRequestUrl?.(url) ?? url
     }
   }
 
@@ -176,11 +298,8 @@ export async function buildMetroConfigInputFromViteConfig(
 
   // no babel by default. the worker throws on a babel plugin it has no port
   // for, so opting back in is explicit rather than something you drift into.
-  const isNativeTransforms =
-    process.env.ONE_METRO_NATIVE_TRANSFORMS === '0'
-      ? false
-      : process.env.ONE_METRO_NATIVE_TRANSFORMS === '1' ||
-        metroPluginOptions.nativeTransforms !== false
+  // When a user adds a custom babel config, respect it rather than forcing native transforms.
+  const { isNativeTransforms } = resolveNativeTransforms(projectRoot, metroPluginOptions)
 
   let nativeWorkerPath: string | undefined
   if (isNativeTransforms) {
@@ -194,11 +313,20 @@ export async function buildMetroConfigInputFromViteConfig(
 
   const defaultConfig: MetroInputConfig = {
     ..._defaultConfig,
+    watcher: {
+      ..._defaultConfig?.watcher,
+      additionalExts: [
+        ...new Set([
+          ...(_defaultConfig?.watcher?.additionalExts ?? []),
+          ...expoEnvAdditionalExts,
+        ]),
+      ],
+    },
     resolver: {
       ..._defaultConfig?.resolver,
       useWatchman,
       blockList,
-      sourceExts: ['js', 'jsx', 'json', 'ts', 'tsx', 'mjs', 'cjs'], // `one` related packages are using `.mjs` extensions. This fixes `.native` files not being resolved correctly when `.mjs` files are present.
+      sourceExts: metroSourceExts,
       resolveRequest: (context, moduleName, platform) => {
         const origResolveRequestFn =
           _defaultConfig?.resolver?.resolveRequest || context.resolveRequest
@@ -230,6 +358,10 @@ export async function buildMetroConfigInputFromViteConfig(
     },
     transformer: {
       ..._defaultConfig?.transformer,
+      // one's router and Expo's optional development env module both use
+      // require.context. Metro installs a throwing runtime stub unless this
+      // graph feature is enabled.
+      unstable_allowRequireContext: true,
       babelTransformerPath: projectResolve(
         projectRoot,
         '@vxrn/vite-plugin-metro/babel-transformer'
@@ -248,7 +380,16 @@ export async function buildMetroConfigInputFromViteConfig(
       : defaultConfigOverrides),
   }
 
-  return { defaultConfig: merged, projectRoot, extraConfig }
+  return {
+    defaultConfig: enforcePackageResolution(
+      enforceWorkspaceVisibility(merged, projectRoot),
+      mainModuleName,
+      config.resolve?.dedupe ?? [],
+      projectRoot
+    ),
+    projectRoot,
+    extraConfig,
+  }
 }
 
 export async function getMetroConfigFromViteConfig(
@@ -274,60 +415,21 @@ export async function getMetroConfigFromViteConfig(
   const { loadConfig } = await projectImport<{
     loadConfig: typeof loadConfigT
   }>(projectRoot, 'metro')
-  const { getDefaultConfig } = await projectImport<{
-    getDefaultConfig: typeof getDefaultConfigT
-  }>(projectRoot, '@expo/metro-config')
-
-  const _defaultConfig: MetroInputConfig = getDefaultConfig(projectRoot) as any
+  const _defaultConfig = getReactNativeDefaultConfig(projectRoot)
 
   if (mainModuleName) {
-    const origRewriteRequestUrl = _defaultConfig!.server!.rewriteRequestUrl!
-
-    // We need to patch Expo's default `config.server.rewriteRequestUrl`
-    // to change how URLs like '/.expo/.virtual-metro-entry.bundle?' are
-    // rewritten.
-    // But since that function is difficult to override, here we borrow
-    // the ExpoGoManifestHandlerMiddleware and use it to resolve the
-    // URL to the main module name.
-    const resolveMainModuleName: (p: { platform: 'ios' | 'android' }) => string =
-      await (async () => {
-        const ExpoGoManifestHandlerMiddleware = (
-          await projectImport(
-            projectRoot,
-            '@expo/cli/build/src/start/server/middleware/ExpoGoManifestHandlerMiddleware.js'
-          )
-        ).default.ExpoGoManifestHandlerMiddleware
-
-        const manifestHandlerMiddleware = new ExpoGoManifestHandlerMiddleware(
-          projectRoot,
-          {}
-        )
-
-        patchExpoGoManifestHandlerMiddlewareWithCustomMainModuleName(
-          manifestHandlerMiddleware,
-          mainModuleName
-        )
-
-        return (p) => {
-          return manifestHandlerMiddleware.resolveMainModuleName({
-            pkg: { main: mainModuleName },
-            platform: p.platform,
-          })
-        }
-      })()
+    const origRewriteRequestUrl = _defaultConfig!.server?.rewriteRequestUrl
+    const resolveMainModuleName = () => mainModuleName
 
     extraConfig.getResolveMainModuleName = resolveMainModuleName
 
     // @ts-expect-error Metro 0.83 made this read-only in types but we need to patch it
     _defaultConfig!.server!.rewriteRequestUrl = (url) => {
-      if (
-        url.includes('/.expo/.virtual-metro-entry.bundle?') ||
-        rootIndexBundleRequestPattern.test(url)
-      ) {
+      if (isMainModuleBundleRequest(url)) {
         return rewriteMainModuleBundleUrl(url, resolveMainModuleName)
       }
 
-      return origRewriteRequestUrl(url)
+      return origRewriteRequestUrl?.(url) ?? url
     }
   }
 
@@ -343,11 +445,8 @@ export async function getMetroConfigFromViteConfig(
 
   // no babel by default. the worker throws on a babel plugin it has no port
   // for, so opting back in is explicit rather than something you drift into.
-  const isNativeTransforms =
-    process.env.ONE_METRO_NATIVE_TRANSFORMS === '0'
-      ? false
-      : process.env.ONE_METRO_NATIVE_TRANSFORMS === '1' ||
-        metroPluginOptions.nativeTransforms !== false
+  // When a user adds a custom babel config, respect it rather than forcing native transforms.
+  const { isNativeTransforms } = resolveNativeTransforms(projectRoot, metroPluginOptions)
 
   let nativeWorkerPath: string | undefined
   if (isNativeTransforms) {
@@ -361,11 +460,20 @@ export async function getMetroConfigFromViteConfig(
 
   const defaultConfig: MetroInputConfig = {
     ..._defaultConfig,
+    watcher: {
+      ..._defaultConfig?.watcher,
+      additionalExts: [
+        ...new Set([
+          ...(_defaultConfig?.watcher?.additionalExts ?? []),
+          ...expoEnvAdditionalExts,
+        ]),
+      ],
+    },
     resolver: {
       ..._defaultConfig?.resolver,
       useWatchman,
       blockList,
-      sourceExts: ['js', 'jsx', 'json', 'ts', 'tsx', 'mjs', 'cjs'], // `one` related packages are using `.mjs` extensions. This somehow fixes `.native` files not being resolved correctly when `.mjs` files are present.
+      sourceExts: metroSourceExts,
       resolveRequest: (context, moduleName, platform) => {
         const origResolveRequestFn =
           _defaultConfig?.resolver?.resolveRequest || context.resolveRequest
@@ -405,6 +513,10 @@ export async function getMetroConfigFromViteConfig(
     },
     transformer: {
       ..._defaultConfig?.transformer,
+      // one's router and Expo's optional development env module both use
+      // require.context. Metro installs a throwing runtime stub unless this
+      // graph feature is enabled.
+      unstable_allowRequireContext: true,
       babelTransformerPath: projectResolve(
         projectRoot,
         '@vxrn/vite-plugin-metro/babel-transformer'
@@ -432,7 +544,12 @@ export async function getMetroConfigFromViteConfig(
   )
 
   return {
-    ...metroConfig,
+    ...enforcePackageResolution(
+      enforceWorkspaceVisibility(metroConfig, projectRoot),
+      mainModuleName,
+      config.resolve?.dedupe ?? [],
+      projectRoot
+    ),
     ...extraConfig,
   } as MetroConfigExtended
 }

package/src/metro-config/glbAssets.test.ts

@@ -0,0 +1,57 @@
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { runInNewContext } from 'node:vm'
+import type { ResolvedConfig } from 'vite'
+import { expect, it } from 'vitest'
+import { buildMetroConfigInputFromViteConfig } from './getMetroConfigFromViteConfig'
+import { transform } from '../transformer/metroNativeWorker'
+
+it('classifies a binary GLB with stock Metro config and registers its identity', async () => {
+  const root = await mkdtemp(join(import.meta.dirname, '.glb-metro-'))
+  const bytes = Buffer.from([0x67, 0x6c, 0x54, 0x46, 2, 0, 0, 0, 0xff, 0x80, 0, 1])
+  await writeFile(join(root, 'sofa.glb'), bytes)
+  try {
+    const { defaultConfig } = await buildMetroConfigInputFromViteConfig(
+      { root } as ResolvedConfig,
+      { watchman: false }
+    )
+    const type = defaultConfig.resolver.assetExts.includes('glb') ? 'asset' : 'module'
+    const result = await transform(
+      { assetRegistryPath: 'react-native/asset-registry', publicPath: '/assets' },
+      root,
+      'sofa.glb',
+      bytes,
+      { dev: true, platform: 'ios', type }
+    )
+    expect(result.output[0].type).toBe('js/module/asset')
+    let descriptor: any
+    runInNewContext(result.output[0].data.code, {
+      __d: (factory: Function) =>
+        factory(
+          {},
+          () => ({
+            registerAsset: (asset: any) => {
+              descriptor = asset
+            },
+          }),
+          {},
+          {},
+          { exports: {} },
+          {},
+          [0]
+        ),
+    })
+    expect(descriptor).toMatchObject({
+      name: 'sofa',
+      type: 'glb',
+      scales: [1],
+      httpServerLocation: '/assets',
+    })
+    expect(descriptor.hash).not.toBe('')
+    expect(descriptor.width).toBeUndefined()
+    expect(descriptor.height).toBeUndefined()
+    expect(await readFile(join(root, 'sofa.glb'))).toEqual(bytes)
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})

package/src/plugins/metroPlugin.ts

@@ -9,8 +9,7 @@ import { checkAndClearMetroCacheFromVite } from '../utils/metroCacheManager'
 
 const { debug } = createDebugger('vite-plugin-metro')
 
-// For Metro and Expo, we only import types here.
-// We use `projectImport` to dynamically import the actual modules
+// for Metro, we only import types here. `projectImport` loads the actual modules
 // at runtime to ensure they are loaded from the user's project root.
 import type MetroT from 'metro'
 import type { loadConfig as loadConfigT } from 'metro'
@@ -72,10 +71,8 @@ export type MetroPluginOptions = {
   /**
    * Overrides the main module name which is normally defined as the `main` field in `package.json`.
    *
-   * This will affect how `/.expo/.virtual-metro-entry.bundle` behaves.
-   *
-   * It can be used to change the entry point of the React Native app without the need of using
-   * the `main` field in `package.json`.
+   * Changes the React Native entry point without requiring a `main` field in
+   * `package.json`.
    */
   mainModuleName?: string
   /**

package/src/transformer/babel-transformer.test.ts

@@ -0,0 +1,118 @@
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import vm from 'node:vm'
+import { describe, expect, it } from 'vitest'
+
+import { transformFromAstSync } from './babel-core'
+// @ts-expect-error: module.exports = has no default export in types, runtime interop provides it
+import babelTransformer from './babel-transformer'
+
+const fixturesDir = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '__fixtures__'
+)
+const virtualFilename = '/proj/node_modules/expo/virtual/env.js'
+const virtualSource = 'export const env = process.env;'
+
+function runBabelTransform(src: string, filename: string, dev: boolean): any {
+  // the transformer leaks BABEL_ENV=development when it was previously
+  // unset; keep that pre-existing leak out of sibling tests.
+  const OLD_BABEL_ENV = process.env.BABEL_ENV
+  try {
+    return (babelTransformer as any).transform({
+      filename,
+      src,
+      options: {
+        projectRoot: fixturesDir,
+        dev,
+        platform: 'ios',
+        customTransformOptions: {
+          environment: 'client',
+          vite: {
+            oneViteMetroBabelConfig: true,
+            babelConfig: {
+              babelrc: false,
+              configFile: false,
+              presets: [],
+              plugins: [],
+            },
+          },
+        },
+      },
+      plugins: [],
+    })
+  } finally {
+    if (OLD_BABEL_ENV === undefined) {
+      delete process.env.BABEL_ENV
+    } else {
+      process.env.BABEL_ENV = OLD_BABEL_ENV
+    }
+  }
+}
+
+function codegen(ast: any, filename: string): string {
+  const out = transformFromAstSync(ast, virtualSource, {
+    filename,
+    babelrc: false,
+    configFile: false,
+    code: true,
+    ast: false,
+  })
+  if (!out?.code) {
+    throw new Error('codegen produced no code')
+  }
+  return out.code
+}
+
+function runCjs(
+  code: string,
+  opts: { requireImpl: (...args: any[]) => any; procEnv: Record<string, string> }
+) {
+  const module = { exports: {} as any }
+  vm.runInNewContext(code, {
+    require: opts.requireImpl,
+    module,
+    exports: module.exports,
+    process: { env: opts.procEnv },
+    console,
+  })
+  return module.exports
+}
+
+const noRequire = () => {
+  throw new Error('unexpected require call')
+}
+
+describe('babel-transformer optional expo virtual env', () => {
+  it('merges .env files over process.env in dev like upstream', () => {
+    const result = runBabelTransform(virtualSource, virtualFilename, true)
+    expect(result.ast).toBeTruthy()
+    const code = codegen(result.ast, virtualFilename)
+    expect(code).toContain('require.context')
+    expect(code).toContain('.env.development.local')
+    const contextModule: any = () => ({
+      default: { EXPO_PUBLIC_SENTINEL_DOTENV: 'dotenv-sentinel-value' },
+    })
+    contextModule.keys = () => ['./.env']
+    const requireImpl: any = noRequire
+    requireImpl.context = () => contextModule
+    const mod = runCjs(code, {
+      requireImpl,
+      procEnv: { EXPO_PUBLIC_SENTINEL_PROC: 'proc-sentinel-value' },
+    })
+    expect(mod.env.EXPO_PUBLIC_SENTINEL_DOTENV).toBe('dotenv-sentinel-value')
+    expect(mod.env.EXPO_PUBLIC_SENTINEL_PROC).toBe('proc-sentinel-value')
+  })
+
+  it('throws a naming error in production like upstream', () => {
+    const result = runBabelTransform(virtualSource, virtualFilename, false)
+    expect(result.ast).toBeTruthy()
+    const mod = runCjs(codegen(result.ast, virtualFilename), {
+      requireImpl: noRequire,
+      procEnv: {},
+    })
+    expect(() => mod.env.EXPO_PUBLIC_ANYTHING).toThrow(
+      'not supported in production bundles'
+    )
+  })
+})