vxrn 1.26.0 → 2.0.0-beta.33.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vxrn",
-  "version": "1.26.0",
+  "version": "2.0.0-beta.33.1",
   "sideEffects": false,
   "type": "module",
   "exports": {
@@ -65,16 +65,16 @@
     "@jridgewell/trace-mapping": "^0.3.25",
     "@react-native/codegen": "^0.86.2",
     "@react-native/dev-middleware": "^0.86.2",
-    "@vxrn/compiler": "1.26.0",
-    "@vxrn/debug": "1.26.0",
-    "@vxrn/query-string": "1.26.0",
-    "@vxrn/resolve": "1.26.0",
-    "@vxrn/safe-area": "1.26.0",
-    "@vxrn/url-parse": "1.26.0",
-    "@vxrn/utils": "1.26.0",
-    "@vxrn/vendor": "1.26.0",
-    "@vxrn/vite-flow": "1.26.0",
-    "@vxrn/vite-plugin-metro": "1.26.0",
+    "@vxrn/compiler": "2.0.0-beta.33.1",
+    "@vxrn/debug": "2.0.0-beta.33.1",
+    "@vxrn/query-string": "2.0.0-beta.33.1",
+    "@vxrn/resolve": "2.0.0-beta.33.1",
+    "@vxrn/safe-area": "2.0.0-beta.33.1",
+    "@vxrn/url-parse": "2.0.0-beta.33.1",
+    "@vxrn/utils": "2.0.0-beta.33.1",
+    "@vxrn/vendor": "2.0.0-beta.33.1",
+    "@vxrn/vite-flow": "2.0.0-beta.33.1",
+    "@vxrn/vite-plugin-metro": "2.0.0-beta.33.1",
     "citty": "^0.1.6",
     "dotenv": "^17.2.1",
     "dotenv-expand": "^12.0.2",
@@ -95,13 +95,14 @@
     "perfect-debounce": "^1.0.0",
     "picocolors": "^1.0.0",
     "pkg-types": "^1.0.3",
-    "rolldown": "^1.2.4",
+    "rolldown": "^1.2.8",
     "semver": "^7.6.3",
     "vite": "^8.2.2",
     "ws": "^8.21.0"
   },
   "devDependencies": {
     "@biomejs/biome": "2.3.3",
+    "@jridgewell/gen-mapping": "^0.3.5",
     "@react-native-community/cli": "^20.2.0",
     "@tamagui/build": "2.6.2",
     "@types/find-node-modules": "^2.1.2",

package/src/patches/builtInDepPatches.ts

@@ -268,36 +268,20 @@ ${contents}
     },
   },
 
-  // fix RNGH crash on RN 0.81+ new architecture
+  // fix RNGH crash on RN 0.86+ new architecture
   // getShadowNodeFromRef crashes when findHostInstance_DEPRECATED returns null
   {
     module: 'react-native-gesture-handler',
     patchFiles: {
-      // no upper bound. this was capped at 2.30.0, but 2.32.0 still ships the
-      // exact unsafe line in all three targets, so the cap silently dropped the
-      // crash guard rather than retiring it. each replacement is a no-op when
-      // its target is absent, so an uncapped range retires itself.
-      version: '>=2.0.0',
+      version: '>=3.0.0',
 
       'lib/module/getShadowNodeFromRef.js': (contents) => {
         return contents?.replace(
-          `return getInternalInstanceHandleFromPublicInstance(findHostInstance_DEPRECATED(ref)).stateNode.node;`,
-          `const hostInstance = findHostInstance_DEPRECATED(ref);
-  if (hostInstance === null || hostInstance === undefined) {
-    return null;
-  }
-  const internalHandle = getInternalInstanceHandleFromPublicInstance(hostInstance);
-  if (internalHandle === null || internalHandle === undefined) {
-    return null;
-  }
-  return internalHandle.stateNode?.node ?? null;`
-        )
-      },
+          `const hostInstance = isAlreadyHostInstance ? ref : findHostInstance_DEPRECATED(ref);
 
-      'lib/commonjs/getShadowNodeFromRef.js': (contents) => {
-        return contents?.replace(
-          `return getInternalInstanceHandleFromPublicInstance(findHostInstance_DEPRECATED(ref)).stateNode.node;`,
-          `const hostInstance = findHostInstance_DEPRECATED(ref);
+  // @ts-ignore Fabric
+  return getInternalInstanceHandleFromPublicInstance(hostInstance).stateNode.node;`,
+          `const hostInstance = isAlreadyHostInstance ? ref : findHostInstance_DEPRECATED(ref);
   if (hostInstance === null || hostInstance === undefined) {
     return null;
   }
@@ -312,10 +296,16 @@ ${contents}
       // metro uses src/ directly via "react-native" field in package.json
       'src/getShadowNodeFromRef.ts': (contents) => {
         return contents?.replace(
-          `return getInternalInstanceHandleFromPublicInstance(
-    findHostInstance_DEPRECATED(ref)
-  ).stateNode.node;`,
-          `const hostInstance = findHostInstance_DEPRECATED(ref);
+          `const hostInstance = isAlreadyHostInstance
+    ? ref
+    : findHostInstance_DEPRECATED(ref);
+
+  // @ts-ignore Fabric
+  return getInternalInstanceHandleFromPublicInstance(hostInstance).stateNode
+    .node;`,
+          `const hostInstance = isAlreadyHostInstance
+    ? ref
+    : findHostInstance_DEPRECATED(ref);
   if (hostInstance === null || hostInstance === undefined) {
     return null;
   }
@@ -507,10 +497,6 @@ install('URLSearchParams', () => URLSearchParams);
   {
     module: 'expo-video',
     patchFiles: {
-      'build/index.js': (contents) => {
-        // bad type export that can't be auto-fixed
-        return contents?.replace(`export { VideoThumbnail } from './VideoThumbnail';`, ``)
-      },
       'build/**/*.js': ['jsx'],
     },
   },
@@ -632,17 +618,13 @@ export const addCustomSourceTransformer = resolveAssetSource.addCustomSourceTran
   },
 
   // a void TurboModule method that throws an Obj-C NSException crashes the app
-  // with a SIGSEGV: ObjCTurboModule::performVoidMethodInvocation converts it to
-  // a JS error (convertNSExceptionToJSError) on the TurboModule method queue,
-  // which touches the Hermes runtime off the JS thread and corrupts the
-  // single-threaded VM. only safe to build the JS error when the method runs
-  // sync (on the JS thread); otherwise log. mirrors the isSync guard added for
-  // value-returning methods in facebook/react-native#50193 (which never covered
-  // the void path). see tests/test/IOS_PROD_CRASH.md
+  // when React Native rethrows it on the TurboModule queue. there is no JS
+  // caller for an async void method to receive an error, so log it instead.
+  // see tests/test/IOS_PROD_CRASH.md
   {
     module: 'react-native',
     patchFiles: {
-      version: '>=0.81.0',
+      version: '>=0.86.0',
 
       'ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModule.mm': (
         contents
@@ -652,20 +634,14 @@ export const addCustomSourceTransformer = resolveAssetSource.addCustomSourceTran
           `    @try {
       [inv invokeWithTarget:strongModule];
     } @catch (NSException *exception) {
-      throw convertNSExceptionToJSError(runtime, exception, std::string{moduleName}, methodNameStr);
+      // Void methods are always async, re-throw instead of converting to
+      // JSError, same as the async branch in performMethodInvocation.
+      @throw exception;
     } @finally {`,
           `    @try {
       [inv invokeWithTarget:strongModule];
     } @catch (NSException *exception) {
-      if (shouldVoidMethodsExecuteSync_) {
-        // sync void methods run on the JS thread — safe to build the JS error.
-        throw convertNSExceptionToJSError(runtime, exception, std::string{moduleName}, methodNameStr);
-      } else {
-        // async void methods run on the TurboModule method queue; building a JS
-        // error here touches the Hermes runtime off the JS thread and corrupts
-        // the VM (SIGSEGV). there is no JS caller to receive it, so log instead.
-        RCTLogError(@"Exception in %s.%s: %@", moduleName, methodNameStr.c_str(), exception.reason);
-      }
+      RCTLogError(@"Exception in %s.%s: %@", moduleName, methodNameStr.c_str(), exception.reason);
     } @finally {`
         )
       },

package/src/plugins/reactNativeDevServer.ts

@@ -11,6 +11,12 @@ import { readFile } from 'node:fs/promises'
 import { createDevMiddleware } from '@react-native/dev-middleware'
 import { createNativeDevEngine } from '../utils/createNativeDevEngine'
 import { getBoundPort } from '../utils/getBoundPort'
+import {
+  getNativeFramePlatform,
+  isNativeBundleFrame,
+  symbolicateNativeStack,
+  type NativeStackFrame,
+} from '../utils/symbolicateNativeStack'
 
 type ClientMessage = {
   type: 'client-log'
@@ -77,6 +83,7 @@ export function createReactNativeDevServerPlugin(
       > = {}
       const devEngineCreating: Record<string, Promise<unknown> | null> = {}
       const warnedProdBundleRequest = new Set<string>()
+      const pendingReloadPlatforms = new Set<'ios' | 'android'>()
 
       const devToolsSocketEndpoints = ['/inspector/device', '/inspector/debug']
       const reactNativeDevToolsUrl = `http://${host}:${getBoundPort(server)}`
@@ -204,8 +211,11 @@ export function createReactNativeDevServerPlugin(
           return
         }
         addConnectedNativeClient()
+        if (pendingReloadPlatforms.has(socket.vxrnPlatform)) {
+          socket.send(JSON.stringify({ type: 'hmr:reload' }))
+        }
 
-        socket.on('message', async (message) => {
+        socket.on('message', (message) => {
           const value = message.toString()
           if (value === 'ping') {
             socket.send('pong')
@@ -219,8 +229,9 @@ export function createReactNativeDevServerPlugin(
             return
           }
           if (update.type === 'hmr:invalidate') {
-            currentEngine.engine.triggerFullBuild()
-            await currentEngine.engine.ensureLatestBuildOutput()
+            // the runtime could not accept an update, so restart it. the bundle
+            // it fetches on the way back settles the engine's pending work
+            // first, so it lands on the current output.
             socket.send(JSON.stringify({ type: 'hmr:reload' }))
           }
         })
@@ -267,6 +278,55 @@ export function createReactNativeDevServerPlugin(
         })
       })
 
+      const getDevEngine = async (platform: 'ios' | 'android') => {
+        while (!devEngines[platform]) {
+          // prevent duplicate creation from concurrent requests
+          if (!devEngineCreating[platform]) {
+            const creating = (async () => {
+              try {
+                console.info(`[vxrn] creating rolldown DevEngine for ${platform}...`)
+                devEngines[platform] = await createNativeDevEngine({
+                  root,
+                  port: getBoundPort(server),
+                  host: typeof host === 'string' ? host : 'localhost',
+                  platform,
+                  serverUrl: `http://${typeof host === 'string' && host !== '0.0.0.0' ? host : 'localhost'}:${getBoundPort(server)}`,
+                  onHmrUpdate: (update) => {
+                    const msg = JSON.stringify(update)
+                    // an update with no clientId is for every client on the
+                    // platform: an error, or a reload after a full rebuild
+                    const target = 'clientId' in update ? update.clientId : undefined
+                    if (update.type === 'hmr:reload' && !target) {
+                      // keep this pending until the rebuilt bundle is served.
+                      // a previous app instance can leave a live socket while
+                      // its replacement is still mounting and connecting.
+                      pendingReloadPlatforms.add(platform)
+                    }
+                    hmrWSS.clients.forEach((client) => {
+                      const nativeClient = client as NativeHmrSocket
+                      if (
+                        nativeClient.readyState === 1 &&
+                        nativeClient.vxrnPlatform === platform &&
+                        (!target || nativeClient.vxrnClientId === target)
+                      ) {
+                        client.send(msg)
+                      }
+                    })
+                  },
+                })
+                console.info(`[vxrn] rolldown DevEngine ready for ${platform}`)
+              } finally {
+                // clear so a failed creation can be retried.
+                devEngineCreating[platform] = null
+              }
+            })()
+            devEngineCreating[platform] = creating
+          }
+          await devEngineCreating[platform]
+        }
+        return devEngines[platform]!
+      }
+
       // React Native bundle handler
       const handleRNBundle: Connect.NextHandleFunction = async (req, res) => {
         const url = new URL(req.url!, `http://${req.headers.host}`)
@@ -281,7 +341,10 @@ export function createReactNativeDevServerPlugin(
         // here would mean a second engine per platform. production native bundles
         // come from the build command instead. say so rather than quietly serving
         // dev bytes to something that asked for production ones.
-        if (url.searchParams.get('dev') === 'false' && !warnedProdBundleRequest.has(platform)) {
+        if (
+          url.searchParams.get('dev') === 'false' &&
+          !warnedProdBundleRequest.has(platform)
+        ) {
           warnedProdBundleRequest.add(platform)
           console.warn(
             `[vxrn] ${platform} bundle requested with dev=false, but the dev server only builds dev bundles. Serving a dev bundle. Use the build command for a production one.`
@@ -289,50 +352,20 @@ export function createReactNativeDevServerPlugin(
         }
 
         try {
-          const bundle = await (async () => {
-            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: getBoundPort(server),
-                      host: typeof host === 'string' ? host : 'localhost',
-                      platform,
-                      serverUrl: `http://${typeof host === 'string' && host !== '0.0.0.0' ? host : 'localhost'}:${getBoundPort(server)}`,
-                      onHmrUpdate: (update) => {
-                        const msg = JSON.stringify(update)
-                        hmrWSS.clients.forEach((client) => {
-                          const nativeClient = client as NativeHmrSocket
-                          if (
-                            nativeClient.readyState === 1 &&
-                            nativeClient.vxrnPlatform === platform &&
-                            (update.type === 'hmr:error' ||
-                              nativeClient.vxrnClientId === update.clientId)
-                          ) {
-                            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]
-            }
-
-            return await devEngines[platform]!.getBundle().then((r) => r.code)
-          })()
-
-          res.writeHead(200, { 'Content-Type': 'text/javascript' })
-          res.end(bundle)
+          const bundle = await (await getDevEngine(platform)).getBundle()
+          // a client that connects after this response starts from the current
+          // route map and does not need the pending reload intended for the
+          // previous runtime.
+          res.once('finish', () => pendingReloadPlatforms.delete(platform))
+
+          // a DevSettings reload requests this exact URL again. native URL
+          // loading may otherwise reuse the first response and restart the app
+          // on a route map from before a file was added or removed.
+          res.writeHead(200, {
+            'Cache-Control': 'no-store',
+            'Content-Type': 'text/javascript',
+          })
+          res.end(bundle.code)
         } catch (err) {
           console.error(` Error building React Native bundle`)
           console.error(err)
@@ -353,10 +386,49 @@ export function createReactNativeDevServerPlugin(
         }
       })
 
-      // Symbolicate endpoint
-      server.middlewares.use('/symbolicate', (_req, res) => {
-        res.writeHead(200, { 'Content-Type': 'text/plain' })
-        res.end('TODO')
+      // resolve a device stack back to authored files through the dev bundle's
+      // source map. react native posts here from LogBox and from console traces.
+      server.middlewares.use('/symbolicate', async (req, res) => {
+        try {
+          const chunks: Buffer[] = []
+          for await (const chunk of req) chunks.push(chunk as Buffer)
+          const body: { stack?: NativeStackFrame[] } = JSON.parse(
+            Buffer.concat(chunks).toString('utf8')
+          )
+          const stack = body.stack
+          if (!Array.isArray(stack)) {
+            throw new Error('expected a `stack` array in the request body')
+          }
+
+          const bundleFrame = stack.find((frame) => isNativeBundleFrame(frame.file))
+          if (!bundleFrame) {
+            // nothing in this stack came from the bundle, so there is nothing to
+            // resolve. hand it straight back rather than inventing frames.
+            res.writeHead(200, { 'Content-Type': 'application/json' })
+            res.end(JSON.stringify({ stack, codeFrame: null }))
+            return
+          }
+
+          const framePlatform = getNativeFramePlatform(bundleFrame.file)
+          const platform = validPlatforms[framePlatform ?? '']
+          if (!platform) {
+            throw new Error(
+              `could not tell which platform "${bundleFrame.file}" was bundled for`
+            )
+          }
+
+          const bundle = await (await getDevEngine(platform)).getBundle()
+          res.writeHead(200, { 'Content-Type': 'application/json' })
+          res.end(JSON.stringify(symbolicateNativeStack(stack, bundle.map)))
+        } catch (err) {
+          console.error(`[vxrn] symbolicate failed`, err)
+          res.writeHead(500, { 'Content-Type': 'application/json' })
+          res.end(
+            JSON.stringify({
+              error: err instanceof Error ? err.message : String(err),
+            })
+          )
+        }
       })
     },
   }

package/src/rn-commands/bundle/buildBundle.ts

@@ -1,5 +1,5 @@
-import path from 'node:path'
 import FSExtra from 'fs-extra'
+import { clearTransformCache } from '@vxrn/compiler'
 import {
   bundle as metroBundle,
   type BundleCommandArgs,
@@ -18,15 +18,29 @@ export async function buildBundle(
   const {
     platform, // Android is not supported yet.
     dev,
-    // bundleEncoding, // Not supported, we are using utf8.
-    // sourcemapUseAbsolutePath,
-    // unstableTransformProfile,
-    // resetCache, // Currently we are not using cache for production builds.
-    // readGlobalCache,
-    // entryFile, // Not supported. With VxRN, we are using a static entry file.
     bundleOutput,
+    // React Native's `--bundle-encoding` names a Node Buffer encoding.
+    bundleEncoding = 'utf8',
     assetsDest,
-    // minify, // Minification is not supported.
+    // `--minify` overrides React Native's default of "minify unless this is a
+    // dev bundle". undefined means the flag was not passed.
+    minify,
+    // `--reset-cache` drops the compiler's transform cache, the only cache a
+    // rolldown production build reads.
+    resetCache,
+    // `--entry-file` names the React Native root module. One generates its own
+    // native entry from the route tree instead, and __vxrnNativeEntryFile is
+    // the supported way to point the build somewhere else.
+    // `--read-global-cache` / `--max-workers` / `--config` / `--transformer` /
+    // `--resolver-option` configure Metro's global cache, worker pool and
+    // resolver. A rolldown production build has none of them: it transforms
+    // from source in-process. React Native's own bundle command ignores
+    // `--read-global-cache` too.
+    // `--unstable-transform-profile` picks a JS engine to target. This pipeline
+    // always downlevels for Hermes, which is what every profile it accepts
+    // ('default', 'hermes', 'hermes-canary') can run.
+    // `--sourcemap-use-absolute-path`, `--sourcemap-sources-root`,
+    // `--asset-catalog-dest` and `--indexed-ram-bundle` are not implemented.
   } = args
 
   const { root } = ctx
@@ -53,6 +67,10 @@ export async function buildBundle(
     process.env.NODE_ENV = 'production'
   }
 
+  if (resetCache) {
+    clearTransformCache()
+  }
+
   console.info(`[vxrn] building native bundle for ${platform}...`)
   const nativeEntryFile = (globalThis as { __vxrnNativeEntryFile?: unknown })
     .__vxrnNativeEntryFile
@@ -67,6 +85,7 @@ export async function buildBundle(
     serverUrl: process.env.ONE_SERVER_URL,
     assetsDest,
     sourcemap: !!args.sourcemapOutput,
+    minify,
   })
   const builtBundle = result.code
 
@@ -76,7 +95,7 @@ export async function buildBundle(
   }
 
   console.info(`Writing bundle to ${bundleOutput}...`)
-  FSExtra.writeFileSync(bundleOutput, builtBundle, { encoding: 'utf8' })
+  FSExtra.writeFileSync(bundleOutput, builtBundle, { encoding: bundleEncoding })
   console.info('Done.')
 
   // Prevent the process not getting exited for some unknown reason.