vxrn 1.12.8 → 1.13.0

package/src/exports/prebuild.ts

@@ -62,6 +62,12 @@ export const prebuild = async ({
       )
     }
 
+    // validate swift 6 workaround was injected into Podfile (outside prebuild try/catch
+    // so a validation error doesn't produce a misleading "Is expo listed?" message)
+    if (!platform || platform === 'ios') {
+      validateSwift6Workaround(root)
+    }
+
     if (!platform || platform === 'ios') {
       console.info(
         `
@@ -206,6 +212,45 @@ Android:
   }
 }
 
+function validateSwift6Workaround(root: string) {
+  const podfilePath = path.join(root, 'ios', 'Podfile')
+  if (!FSExtra.existsSync(podfilePath)) return
+
+  // check opt-out
+  const propsPath = path.join(root, 'ios', 'Podfile.properties.json')
+  if (FSExtra.existsSync(propsPath)) {
+    try {
+      const props = JSON.parse(FSExtra.readFileSync(propsPath, 'utf8'))
+      if (props['one.disableSwift6Workaround'] === 'true') return
+    } catch {}
+  }
+
+  // check version — only needed for <56
+  try {
+    const emcPkgPath = resolvePath('expo-modules-core/package.json', root)
+    const emcVersion = JSON.parse(FSExtra.readFileSync(emcPkgPath, 'utf8')).version
+    const major = Number.parseInt(emcVersion.match(/^(\d+)/)?.[1] || '0', 10)
+    if (major >= 56) return
+  } catch {}
+
+  const podfile = FSExtra.readFileSync(podfilePath, 'utf8')
+  if (!podfile.includes('SWIFT_STRICT_CONCURRENCY')) {
+    console.warn(
+      colors.yellow(`
+⚠️  Your ios/Podfile is missing the Swift 6 workaround for expo-modules-core.
+   Without this, your iOS build will fail with Swift concurrency errors.
+
+   Fix: add "vxrn/expo-plugin" to your app.json plugins and re-run prebuild.
+
+   To disable this check: set "one.disableSwift6Workaround": "true"
+   in ios/Podfile.properties.json.
+
+   See: expo/expo#43199
+`)
+    )
+  }
+}
+
 function isMissingCliDependency(error) {
   return (
     error.code === 'MODULE_NOT_FOUND' &&

package/src/exports/serve.ts

@@ -6,7 +6,8 @@ import { applyCompression, createProdServer } from './createServer'
 export { loadEnv } from '../exports/loadEnv'
 export * from '../utils/getServerEntry'
 export { createProdServer, applyCompression } from './createServer'
-export { serveStaticAssets } from './serveStaticAssets'
+export { serveStaticAssets, compileCacheRules } from './serveStaticAssets'
+export type { CompiledCacheRules } from './serveStaticAssets'
 
 export const serve = async ({
   afterRegisterRoutes,

package/src/exports/serveStaticAssets.ts

@@ -1,24 +1,87 @@
 import { serveStatic } from '@hono/node-server/serve-static'
 import type { Context } from 'hono'
+import micromatch from 'micromatch'
 
 // hashed assets can be cached forever, html must revalidate
-const hashedAssetRe = /[.-][a-zA-Z0-9_-]{8,}\.\w+$/
+const hashedAssetRe = /[.-](?=[a-zA-Z0-9_-]*\d)[a-zA-Z0-9_-]{8,}\.\w+$/
+
+export type CompiledCacheRules = { re: RegExp; values: string[] }
+
+/**
+ * compile a cacheControl config (glob → header) into a single regex.
+ * each unique header value gets a capturing group — one regex.test()
+ * per request, then the matched group index maps to the header value.
+ */
+export function compileCacheRules(
+  cacheControl: Record<string, string>
+): CompiledCacheRules {
+  // group patterns by header value
+  const groups = new Map<string, string[]>()
+  for (const [pattern, value] of Object.entries(cacheControl)) {
+    let arr = groups.get(value)
+    if (!arr) {
+      arr = []
+      groups.set(value, arr)
+    }
+    arr.push(pattern)
+  }
+
+  // each group becomes a capturing group: (pat1|pat2)|(pat3)
+  // matched group index → values[index]
+  const values: string[] = []
+  const groupSources: string[] = []
+
+  for (const [value, patterns] of groups) {
+    values.push(value)
+    const sources = patterns.map((p) => micromatch.makeRe(p).source)
+    groupSources.push(`(${sources.join('|')})`)
+  }
+
+  const re = new RegExp(groupSources.join('|'))
+  return { re, values }
+}
 
 export async function serveStaticAssets({
   context,
   next,
   outDir = 'dist',
+  cacheRules,
 }: {
   context: Context
   next?: () => Promise<void>
   outDir?: string
+  cacheRules?: CompiledCacheRules
 }) {
   let didCallNext = false
 
+  const root = `./${outDir}/client`
+  // path.join normalizes "./" away, so pre-compute the normalized prefix
+  const rootPrefix = `${outDir}/client/`
+
   const response = await serveStatic({
-    root: `./${outDir}/client`,
-    onFound: (path, c) => {
-      if (hashedAssetRe.test(path)) {
+    root,
+    onFound: (fsPath, c) => {
+      // onFound receives the joined fs path (e.g. "dist/client/foo.js")
+      // strip root prefix to get the URL-relative path for glob matching
+      const path = fsPath.startsWith(rootPrefix)
+        ? fsPath.slice(rootPrefix.length)
+        : fsPath
+
+      // single regex test for all custom rules
+      if (cacheRules) {
+        const m = cacheRules.re.exec(path)
+        if (m) {
+          // find which capturing group matched
+          for (let i = 1; i < m.length; i++) {
+            if (m[i] !== undefined) {
+              c.header('Cache-Control', cacheRules.values[i - 1]!)
+              return
+            }
+          }
+        }
+      }
+
+      if (hashedAssetRe.test(fsPath)) {
         c.header('Cache-Control', 'public, immutable, max-age=31536000')
       } else {
         c.header('Cache-Control', 'public, max-age=0, must-revalidate')

package/src/index.ts

@@ -25,5 +25,3 @@ export * from './plugins/rollupRemoveUnusedImports'
 export * from './plugins/autoDepOptimizePlugin'
 
 export * from './types'
-
-export { prebuildReactNativeModules } from './utils/swapPrebuiltReactModules'

package/src/patches/builtInDepPatches.ts

@@ -28,6 +28,35 @@ export const builtInDepPatches: DepPatch[] = [
     },
   },
 
+  // @react-navigation/core 7.17 renamed createComponentForStaticNavigation to
+  // createComponentForStaticConfigDeprecated, breaking @react-navigation/native
+  // which still imports the old name. re-export the old name as an alias.
+  {
+    module: '@react-navigation/core',
+    patchFiles: {
+      'lib/module/index.js': (contents) => {
+        assertString(contents)
+        // only patch if the old export is missing and the new one exists
+        if (contents.includes('createComponentForStaticNavigation')) return
+        if (!contents.includes('createComponentForStaticConfigDeprecated')) return
+        return contents.replace(
+          /export \{ createComponentForStaticConfigDeprecated as createComponentForStaticConfig,/,
+          'export { createComponentForStaticConfigDeprecated as createComponentForStaticConfig, createComponentForStaticConfigDeprecated as createComponentForStaticNavigation,'
+        )
+      },
+
+      'lib/commonjs/index.js': (contents) => {
+        if (!contents) return
+        if (contents.includes('createComponentForStaticNavigation')) return
+        if (!contents.includes('createComponentForStaticConfigDeprecated')) return
+        return contents.replace(
+          /createComponentForStaticConfigDeprecated as createComponentForStaticConfig,/,
+          'createComponentForStaticConfigDeprecated as createComponentForStaticConfig, createComponentForStaticConfigDeprecated as createComponentForStaticNavigation,'
+        )
+      },
+    },
+  },
+
   // react-native-web doesn't export unstable_batchedUpdates but react-native does,
   // so libraries like @legendapp/list break when aliased to rnw on web
   {

package/src/plugins/clientInjectPlugin.ts

@@ -1,12 +1,5 @@
-import path from 'node:path'
-
-import type { HmrOptions, Plugin, ResolvedConfig, UserConfig } from 'vite'
-import { isNativeEnvironment } from '../utils/environmentUtils'
-import { getResolvedConfig, setResolvedConfig } from './getResolvedConfigSubset'
-
-let config: ResolvedConfig | null
-
-const isObject = (x: any): x is object => x && typeof x === 'object'
+import type { Plugin } from 'vite'
+import { setResolvedConfig } from './getResolvedConfigSubset'
 
 export function getServerConfigPlugin() {
   return {
@@ -22,103 +15,3 @@ export function getServerConfigPlugin() {
     },
   } satisfies Plugin
 }
-
-/**
- * some values used by the client needs to be dynamically injected by the server
- * @server-only
- */
-export function nativeClientInjectPlugin(): Plugin {
-  let injectConfigValues: (code: string) => string
-
-  return {
-    name: 'vite:native-client-inject',
-
-    async buildStart() {
-      const config = getResolvedConfig()
-
-      const resolvedServerHostname = config.server.host || '127.0.0.1'
-      const resolvedServerPort = config.server!.port! || 5173
-      const devBase = config.base || '/'
-
-      const serverHost = `${resolvedServerHostname}:${resolvedServerPort}${devBase}`
-
-      let hmrConfig = config.server!.hmr
-      hmrConfig = isObject(hmrConfig) ? (hmrConfig as HmrOptions) : undefined
-
-      const host = hmrConfig?.host || null
-      const protocol = hmrConfig?.protocol || null
-      const timeout = hmrConfig?.timeout || 30000
-      const overlay = hmrConfig?.overlay !== false
-      const isHmrServerSpecified = !!hmrConfig?.server
-
-      // hmr.clientPort -> hmr.port
-      // -> (24678 if middleware mode and HMR server is not specified) -> new URL(import.meta.url).port
-      let port = hmrConfig?.clientPort || hmrConfig?.port || null
-      if (config.server.middlewareMode && !isHmrServerSpecified) {
-        port ||= 24678
-      }
-
-      let directTarget = hmrConfig?.host || resolvedServerHostname
-      directTarget += `:${hmrConfig?.port || resolvedServerPort}`
-      directTarget += devBase
-
-      let hmrBase = devBase
-      if (hmrConfig?.path) {
-        hmrBase = path.posix.join(hmrBase, hmrConfig.path)
-      }
-
-      const serializedDefines = serializeDefine(config.define || {})
-
-      const modeReplacement = escapeReplacement(config.mode!)
-      const baseReplacement = escapeReplacement(devBase)
-      const definesReplacement = () => serializedDefines
-      const serverHostReplacement = escapeReplacement(serverHost)
-      const hmrProtocolReplacement = escapeReplacement(protocol)
-      const hmrHostnameReplacement = escapeReplacement(host)
-      const hmrPortReplacement = escapeReplacement(port)
-      const hmrDirectTargetReplacement = escapeReplacement(directTarget)
-      const hmrBaseReplacement = escapeReplacement(hmrBase)
-      const hmrTimeoutReplacement = escapeReplacement(timeout)
-      const hmrEnableOverlayReplacement = escapeReplacement(overlay)
-
-      injectConfigValues = (code: string) => {
-        return code
-          .replace(`__MODE__`, modeReplacement)
-          .replace(/__BASE__/g, baseReplacement)
-          .replace(`__DEFINES__`, definesReplacement)
-          .replace(`__SERVER_HOST__`, serverHostReplacement)
-          .replace(`__HMR_PROTOCOL__`, hmrProtocolReplacement)
-          .replace(`__HMR_HOSTNAME__`, hmrHostnameReplacement)
-          .replace(`__HMR_PORT__`, hmrPortReplacement)
-          .replace(`__HMR_DIRECT_TARGET__`, hmrDirectTargetReplacement)
-          .replace(`__HMR_BASE__`, hmrBaseReplacement)
-          .replace(`__HMR_TIMEOUT__`, hmrTimeoutReplacement)
-          .replace(`__HMR_ENABLE_OVERLAY__`, hmrEnableOverlayReplacement)
-      }
-    },
-
-    applyToEnvironment(environment) {
-      return isNativeEnvironment(environment)
-    },
-
-    transform(code, id) {
-      if (id.includes('vite-native-client/dist/esm/client.')) {
-        return injectConfigValues(code)
-      }
-    },
-  }
-}
-
-function escapeReplacement(value: string | number | boolean | null) {
-  const jsonValue = JSON.stringify(value)
-  return () => jsonValue
-}
-
-function serializeDefine(define: Record<string, any>): string {
-  let res = `{`
-  for (const key in define) {
-    const val = define[key]
-    res += `${JSON.stringify(key)}: ${typeof val === 'string' ? `(${val})` : JSON.stringify(val)}, `
-  }
-  return res + `}`
-}

package/src/plugins/reactNativeDevAssetPlugin.ts

@@ -5,20 +5,6 @@ import type { Plugin, ResolvedConfig } from 'vite'
 import colors from 'picocolors'
 import { isNativeEnvironment } from '../utils/environmentUtils'
 
-const IMAGE_ASSET_EXTS = [
-  'png',
-  'jpg',
-  'jpeg',
-  'bmp',
-  'gif',
-  'webp',
-  'psd',
-  'svg',
-  'tiff',
-  'ktx',
-]
-const IMAGE_ASSET_EXTS_SET = new Set(IMAGE_ASSET_EXTS)
-
 const ASSET_DEST_DIR = 'assets'
 /** `/assets` is too common and might conflict with web, using another path for dev server in development. */
 const DEV_ASSET_DEST_PATH = '__vxrn_dev_native_assets'
@@ -173,10 +159,3 @@ export default asset;
     },
   }
 }
-
-function isAssetTypeAnImage(
-  /** Normally an file extension without the leading dot. */
-  type: string
-) {
-  return IMAGE_ASSET_EXTS_SET.has(type)
-}

package/src/plugins/reactNativeDevServer.ts

@@ -5,15 +5,9 @@ import {
   removeConnectedNativeClient,
 } from '../utils/connectedNativeClients'
 import type { VXRNOptionsFilled } from '../config/getOptionsFilled'
-import { clearCachedBundle, getReactNativeBundle } from '../utils/getReactNativeBundle'
-import { hotUpdateCache } from '../utils/hotUpdateCache'
 import { URL } from 'node:url'
-import { existsSync } from 'node:fs'
-import { readFile, writeFile } from 'node:fs/promises'
 import { createDevMiddleware } from '@react-native/dev-middleware'
-import { runOnWorker } from '../worker'
-import { getCacheDir } from '../utils/getCacheDir'
-import { debounce } from 'perfect-debounce'
+import { createNativeDevEngine } from '../utils/createNativeDevEngine'
 
 type ClientMessage = {
   type: 'client-log'
@@ -26,15 +20,12 @@ export function createReactNativeDevServerPlugin(
     Pick<VXRNOptionsFilled, 'cacheDir' | 'debugBundle' | 'debugBundlePaths' | 'entries'>
   >
 ): Plugin {
-  let hmrSocket: WebSocket | null = null
-
   return {
     name: 'vite-plugin-react-native-server',
 
     configureServer(server: ViteDevServer) {
       const { host, port } = server.config.server
       const { root } = server.config
-      const cacheDir = options?.cacheDir || getCacheDir(root)
       const hmrWSS = new WebSocketServer({ noServer: true })
       const clientWSS = new WebSocketServer({ noServer: true })
 
@@ -49,29 +40,41 @@ export function createReactNativeDevServerPlugin(
 
       // link up sockets
       server.httpServer?.on('upgrade', (req, socket, head) => {
+        const url = req.url || ''
+
         // devtools sockets
         for (const endpoint of devToolsSocketEndpoints) {
-          if (req.url.startsWith(endpoint)) {
+          if (url.startsWith(endpoint)) {
             const wss = websocketEndpoints[endpoint]
             wss.handleUpgrade(req, socket, head, (ws) => {
               wss.emit('connection', ws, req)
             })
+            return
           }
         }
 
-        // hmr socket
-        if (
-          req.url.startsWith(
-            '/__hmr'
-          ) /* TODO: handle '/__hmr?platform=ios' and android differently */
-        ) {
+        // rolldown HMR socket (used by rolldown dev() HMR client)
+        if (url.startsWith('/hot')) {
           hmrWSS.handleUpgrade(req, socket, head, (ws) => {
+            // listen for module registration messages from client
+            ws.on('message', async (data: any) => {
+              try {
+                const msg = JSON.parse(data.toString())
+                if (msg.type === 'hmr:module-registered' && msg.modules) {
+                  const currentEngine = devEngines['ios'] || devEngines['android']
+                  if (currentEngine?.engine) {
+                    await currentEngine.engine.registerModules('vxrn-dev', msg.modules)
+                  }
+                }
+              } catch {}
+            })
             hmrWSS.emit('connection', ws, req)
           })
+          return
         }
 
         // client socket
-        if (req.url === '/__client') {
+        if (url === '/__client') {
           clientWSS.handleUpgrade(req, socket, head, (ws) => {
             clientWSS.emit('connection', ws, req)
           })
@@ -131,24 +134,12 @@ export function createReactNativeDevServerPlugin(
         android: 'android',
       }
 
-      // Handle React Native endpoints
-      server.middlewares.use('/file', async (req, res) => {
-        const url = new URL(req.url!, `http://${req.headers.host}`)
-        const file = url.searchParams.get('file')
-
-        if (file) {
-          const source = hotUpdateCache.get(file)
-          if (!source) {
-            console.warn(`No hot source found for`, file)
-            res.writeHead(200, { 'Content-Type': 'text/javascript' })
-            res.end('')
-            return
-          }
-
-          res.writeHead(200, { 'Content-Type': 'text/javascript' })
-          res.end(source)
-        }
-      })
+      // rolldown DevEngine instances (per platform)
+      const devEngines: Record<
+        string,
+        Awaited<ReturnType<typeof createNativeDevEngine>> | null
+      > = {}
+      const devEngineCreating: Record<string, Promise<any> | null> = {}
 
       // React Native bundle handler
       const handleRNBundle: Connect.NextHandleFunction = async (req, res) => {
@@ -162,47 +153,39 @@ export function createReactNativeDevServerPlugin(
 
         try {
           const bundle = await (async () => {
-            if (typeof options?.debugBundle === 'string' && options.debugBundlePaths) {
-              const path = options.debugBundlePaths[platform]
-              if (existsSync(path)) {
-                console.info(`  !!! - serving debug bundle from`, path)
-                return await readFile(path, 'utf-8')
+            if (!devEngines[platform]) {
+              // prevent duplicate creation from concurrent requests
+              if (!devEngineCreating[platform]) {
+                devEngineCreating[platform] = (async () => {
+                  try {
+                    console.info(`[vxrn] creating rolldown DevEngine for ${platform}...`)
+                    devEngines[platform] = await createNativeDevEngine({
+                      root,
+                      port: port || 8081,
+                      host: typeof host === 'string' ? host : 'localhost',
+                      platform,
+                      serverUrl: `http://${typeof host === 'string' && host !== '0.0.0.0' ? host : 'localhost'}:${port || 8081}`,
+                      onHmrUpdate: (update) => {
+                        const msg = JSON.stringify(update)
+                        hmrWSS.clients.forEach((client: any) => {
+                          if (client.readyState === 1) {
+                            client.send(msg)
+                          }
+                        })
+                      },
+                    })
+                    console.info(`[vxrn] rolldown DevEngine ready for ${platform}`)
+                  } catch (err) {
+                    // clear so next request retries instead of permanently failing
+                    devEngineCreating[platform] = null
+                    throw err
+                  }
+                })()
               }
+              await devEngineCreating[platform]
             }
 
-            const getRnBundleOptions = {
-              root,
-              cacheDir,
-              server: {
-                port: port,
-                url: `http://${host}:${port}`,
-              },
-              entries: { native: options?.entries?.native || './src/entry-native.tsx' },
-              ...options,
-            }
-
-            let outBundle = process.env.VXRN_WORKER_BUNDLE
-              ? await runOnWorker('bundle-react-native', {
-                  options: getRnBundleOptions,
-                  platform,
-                })
-              : await getReactNativeBundle(getRnBundleOptions, platform, {
-                  mode: process.env.RN_SERVE_PROD_BUNDLE ? 'prod' : 'dev',
-                })
-
-            if (server.config.webSocketToken) {
-              outBundle = `globalThis.__VITE_WS_TOKEN__ = "${server.config.webSocketToken}";\n${outBundle}`
-            }
-
-            if (options?.debugBundle && options.debugBundlePaths) {
-              const path = options.debugBundlePaths[platform]
-              if (!existsSync(path)) {
-                console.info(`  !!! - writing debug bundle to`, path)
-                await writeFile(path, outBundle)
-              }
-            }
-
-            return outBundle
+            return await devEngines[platform]!.getBundle().then((r) => r.code)
           })()
 
           res.writeHead(200, { 'Content-Type': 'text/javascript' })
@@ -238,16 +221,6 @@ export function createReactNativeDevServerPlugin(
         res.writeHead(200, { 'Content-Type': 'text/plain' })
         res.end('TODO')
       })
-
-      // Clear bundle cache on file changes (debounced to avoid CPU spikes during builds)
-      const debouncedClearCache = debounce(clearCachedBundle, 100)
-      server.watcher.on('change', (path: string) => {
-        // Skip clearing cache for dist files to avoid loops during builds
-        if (path.includes('/dist/') || path.includes('\\dist\\')) {
-          return
-        }
-        debouncedClearCache()
-      })
     },
   }
 }

package/src/plugins/serverExtensions.test.ts

@@ -63,26 +63,24 @@ describe('platform-specific-resolve', () => {
       vi.restoreAllMocks()
     })
 
-    it('errors when .server file is explicitly imported on client', async () => {
+    it('stubs .server file when explicitly imported on client', async () => {
       const plugin = await getPlatformResolvePlugin()
       const resolveId = plugin.resolveId as Function
 
       const ctx = createMockContext('client', '/src/db.server.ts')
 
-      await expect(
-        resolveId.call(ctx, './db.server', '/src/page.tsx', {})
-      ).rejects.toThrow('.server file cannot be imported on client')
+      const result = await resolveId.call(ctx, './db.server', '/src/page.tsx', {})
+      expect(result).toEqual({ id: '\0server-only-stub:./db.server' })
     })
 
-    it('errors when .server file is explicitly imported on ios', async () => {
+    it('stubs .server file when explicitly imported on ios', async () => {
       const plugin = await getPlatformResolvePlugin()
       const resolveId = plugin.resolveId as Function
 
       const ctx = createMockContext('ios', '/src/db.server.ts')
 
-      await expect(
-        resolveId.call(ctx, './db.server', '/src/page.tsx', {})
-      ).rejects.toThrow('.server file cannot be imported on ios')
+      const result = await resolveId.call(ctx, './db.server', '/src/page.tsx', {})
+      expect(result).toEqual({ id: '\0server-only-stub:./db.server' })
     })
 
     it('allows .server file import on ssr', async () => {