vxrn 1.25.3 → 1.25.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vxrn",
-  "version": "1.25.3",
+  "version": "1.25.5",
   "sideEffects": false,
   "type": "module",
   "exports": {
@@ -62,16 +62,16 @@
     "@expo/config-plugins": "~57.0.6",
     "@hono/node-server": "^1.19.14",
     "@react-native/dev-middleware": "^0.86.2",
-    "@vxrn/compiler": "1.25.3",
-    "@vxrn/debug": "1.25.3",
-    "@vxrn/query-string": "1.25.3",
-    "@vxrn/resolve": "1.25.3",
-    "@vxrn/safe-area": "1.25.3",
-    "@vxrn/url-parse": "1.25.3",
-    "@vxrn/utils": "1.25.3",
-    "@vxrn/vendor": "1.25.3",
-    "@vxrn/vite-flow": "1.25.3",
-    "@vxrn/vite-plugin-metro": "1.25.3",
+    "@vxrn/compiler": "1.25.5",
+    "@vxrn/debug": "1.25.5",
+    "@vxrn/query-string": "1.25.5",
+    "@vxrn/resolve": "1.25.5",
+    "@vxrn/safe-area": "1.25.5",
+    "@vxrn/url-parse": "1.25.5",
+    "@vxrn/utils": "1.25.5",
+    "@vxrn/vendor": "1.25.5",
+    "@vxrn/vite-flow": "1.25.5",
+    "@vxrn/vite-plugin-metro": "1.25.5",
     "citty": "^0.1.6",
     "dotenv": "^17.2.1",
     "dotenv-expand": "^12.0.2",

package/src/plugins/reactNativeDevServer.ts

@@ -1,5 +1,5 @@
 import type { Connect, Plugin, ViteDevServer } from 'vite'
-import { WebSocketServer } from 'ws'
+import { WebSocketServer, type WebSocket } from 'ws'
 import { createMessageSocket } from '@vxrn/utils'
 import {
   addConnectedNativeClient,
@@ -17,6 +17,11 @@ type ClientMessage = {
   data: string[]
 }
 
+type NativeHmrSocket = WebSocket & {
+  vxrnClientId: string
+  vxrnPlatform: 'ios' | 'android'
+}
+
 export function createReactNativeDevServerPlugin(
   options?: Partial<
     Pick<VXRNOptionsFilled, 'cacheDir' | 'debugBundle' | 'debugBundlePaths' | 'entries'>
@@ -61,18 +66,17 @@ export function createReactNativeDevServerPlugin(
 
         // rolldown HMR socket (used by rolldown dev() HMR client)
         if (url.startsWith('/hot')) {
+          const hmrUrl = new URL(url, `http://${req.headers.host || 'localhost'}`)
+          const platform = validPlatforms[hmrUrl.searchParams.get('platform') || '']
+          const clientId = hmrUrl.searchParams.get('clientId')
+          if (!platform || !clientId) {
+            socket.destroy()
+            return
+          }
           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 {}
+            Object.assign(ws, {
+              vxrnClientId: clientId,
+              vxrnPlatform: platform,
             })
             hmrWSS.emit('connection', ws, req)
           })
@@ -95,17 +99,47 @@ export function createReactNativeDevServerPlugin(
         }
       })
 
-      hmrWSS.on('connection', (socket) => {
+      hmrWSS.on('connection', async (socket: NativeHmrSocket) => {
+        const currentEngine = devEngines[socket.vxrnPlatform]
+        if (!currentEngine) {
+          socket.close(1013, 'native dev engine unavailable')
+          return
+        }
+
+        try {
+          await currentEngine.engine.registerClient(socket.vxrnClientId)
+        } catch (error) {
+          console.error('[hmr] failed to register native client', error)
+          socket.close(1011, 'native HMR registration failed')
+          return
+        }
         addConnectedNativeClient()
 
-        socket.on('message', (message) => {
-          if (message.toString().includes('ping')) {
+        socket.on('message', async (message) => {
+          const value = message.toString()
+          if (value === 'ping') {
             socket.send('pong')
+            return
+          }
+
+          let update: { type?: string }
+          try {
+            update = JSON.parse(value)
+          } catch {
+            return
+          }
+          if (update.type === 'hmr:invalidate') {
+            currentEngine.engine.triggerFullBuild()
+            await currentEngine.engine.ensureLatestBuildOutput()
+            socket.send(JSON.stringify({ type: 'hmr:reload' }))
           }
         })
 
         socket.on('close', () => {
           removeConnectedNativeClient()
+          currentEngine.engine.removeClient(socket.vxrnClientId).catch((error) => {
+            console.error('[hmr] failed to remove native client', error)
+          })
         })
 
         socket.on('error', (error) => {
@@ -181,8 +215,14 @@ export function createReactNativeDevServerPlugin(
                       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: any) => {
-                          if (client.readyState === 1) {
+                        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)
                           }
                         })

package/src/utils/createNativeDevEngine.test.ts

@@ -1,12 +1,107 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { dev } from 'rolldown/experimental'
 import { describe, expect, it } from 'vitest'
 import {
   getHermesSWCIncludes,
+  getHmrRuntimeSource,
   getNativeTransformConfig,
   hmrClientNoopPlugin,
   vxrnCompilerPlugin,
   wrapNativeBundleModuleScope,
 } from './createNativeDevEngine'
 
+describe('native Rolldown HMR runtime', () => {
+  it(
+    'registers a Rolldown 1.2 client and applies a self-accepted patch',
+    { timeout: 30_000 },
+    async () => {
+      const testRoot = await mkdtemp(join(tmpdir(), 'vxrn-native-hmr-'))
+      const entry = join(testRoot, 'entry.js')
+      const source = (version: string) => `
+globalThis.__vxrnHmrBody = '${version}'
+export const value = '${version}'
+if (import.meta.hot) {
+  import.meta.hot.accept((next) => {
+    globalThis.__vxrnHmrAccepted = next.value
+  })
+}
+`
+      await writeFile(entry, source('v1'))
+
+      let resolveInitialOutput!: (output: any) => void
+      const initialOutput = new Promise<any>((resolve) => {
+        resolveInitialOutput = resolve
+      })
+      let resolveHmrUpdate!: (output: any) => void
+      const hmrUpdate = new Promise<any>((resolve) => {
+        resolveHmrUpdate = resolve
+      })
+      const engine = await dev(
+        {
+          cwd: testRoot,
+          input: entry,
+          experimental: { devMode: { implement: getHmrRuntimeSource() } },
+        },
+        { format: 'esm' },
+        {
+          onOutput(result) {
+            resolveInitialOutput(result)
+          },
+          onHmrUpdates(result) {
+            if (!(result instanceof Error) && result.changedFiles.length) {
+              resolveHmrUpdate(result)
+            }
+          },
+        }
+      )
+
+      try {
+        await engine.run()
+        const initial = await initialOutput
+        if (initial instanceof Error) throw initial
+        const chunk = initial.output.find(
+          (item: any) => item.type === 'chunk' && item.isEntry
+        )
+        expect(chunk).toBeTruthy()
+
+        delete (globalThis as any).__rolldown_runtime__
+        await import(
+          `data:text/javascript;base64,${Buffer.from(chunk.code).toString('base64')}`
+        )
+        const runtime = (globalThis as any).__rolldown_runtime__
+        expect(typeof runtime.clientId).toBe('string')
+        await engine.registerClient(runtime.clientId)
+
+        await new Promise((resolve) => setTimeout(resolve, 100))
+        await writeFile(entry, source('v2'))
+        const result = await Promise.race([
+          hmrUpdate,
+          new Promise((_, reject) =>
+            setTimeout(() => reject(new Error('timed out waiting for HMR patch')), 10_000)
+          ),
+        ])
+        const patch = result.updates.find(
+          (item: any) =>
+            item.clientId === runtime.clientId && item.update.type === 'Patch'
+        )?.update
+        expect(patch).toBeTruthy()
+
+        expect(runtime.applyHmrUpdate(patch.code, patch.changedIds, patch.seq)).toBe(true)
+        expect((globalThis as any).__vxrnHmrBody).toBe('v2')
+        expect((globalThis as any).__vxrnHmrAccepted).toBe('v2')
+      } finally {
+        await engine.close()
+        await rm(testRoot, { recursive: true, force: true })
+        delete (globalThis as any).__rolldown_runtime__
+        delete (globalThis as any).__vxrnHmrBody
+        delete (globalThis as any).__vxrnHmrAccepted
+      }
+    }
+  )
+})
+
 // use a root with no .env files so only the platform defines are present
 const root = '/tmp/vxrn-native-env-define-test-nonexistent'
 

package/src/utils/createNativeDevEngine.ts

@@ -10,6 +10,7 @@ import { basename, dirname, extname, join, relative, resolve } from 'node:path'
 import { copyFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs'
 import { pathToFileURL } from 'node:url'
 import type { InputOptions, OutputOptions, Plugin, RolldownOutput } from 'rolldown'
+import type { DevEngine } from 'rolldown/experimental'
 import { normalizePath } from 'vite'
 import { DEFAULT_ASSET_EXTS } from '../constants/defaults'
 import { getNativePrelude } from '../runtime/native-prelude'
@@ -47,11 +48,22 @@ interface NativeDevEngineOptions {
   platform: 'ios' | 'android'
   serverUrl?: string
   plugins?: Plugin[]
-  onHmrUpdate?: (update: { type: string; code?: string }) => void
+  onHmrUpdate?: (update: NativeHmrUpdate) => void
 }
 
+export type NativeHmrUpdate =
+  | {
+      type: 'hmr:update'
+      clientId: string
+      code: string
+      changedIds: string[]
+      seq: number
+    }
+  | { type: 'hmr:reload'; clientId: string }
+  | { type: 'hmr:error' }
+
 interface NativeDevEngineResult {
-  engine: any
+  engine: DevEngine
   getBundle: () => Promise<{ code: string }>
   close: () => Promise<void>
 }
@@ -227,7 +239,7 @@ function getNativePlugins(
     // flowStripPlugin so react-native's Flow `.js` specs reach codegen with their
     // type argument intact. stripping Flow first would erase it (which is why the
     // codegen "didn't run for <Component>" warning fired).
-    vxrnCompilerPlugin(platform, dev),
+    vxrnCompilerPlugin(platform, dev, root),
     // strip Flow from any react-native / @react-native `.js` the compiler didn't
     // handle, the guaranteed safety net before rolldown's oxc core parse (which
     // can't parse Flow). now downstream of the compiler, so codegen sees the types.
@@ -450,18 +462,18 @@ export async function createNativeDevEngine(
     outro: `
 try {
   var __WS = (init_WebSocket(), __toCommonJS(WebSocket_exports)).default;
-  var __hmrUrl = 'ws://${resolvedHost}:${port}/hot';
+  var __hmrUrl = 'ws://${resolvedHost}:${port}/hot?platform=${platform}&clientId=' + encodeURIComponent(__rolldown_runtime__.clientId);
   var __hmrWS = new __WS(__hmrUrl);
   __hmrWS.onmessage = function(event) {
     try {
       var msg = JSON.parse(event.data);
       var g = typeof global !== 'undefined' ? global : globalThis;
       if (msg.type === 'hmr:update' && msg.code) {
-        if (g.globalEvalWithSourceUrl) g.globalEvalWithSourceUrl(msg.code);
-        else (0, eval)(msg.code);
-        setTimeout(function() {
-          try { if (g.__ReactRefresh) g.__ReactRefresh.performReactRefresh(); } catch(e) {}
-        }, 50);
+        var applied = __rolldown_runtime__.applyHmrUpdate(msg.code, msg.changedIds, msg.seq);
+        if (!applied) {
+          var updateSettings = g.__turboModuleProxy ? g.__turboModuleProxy('DevSettings') : null;
+          if (updateSettings && updateSettings.reload) updateSettings.reload();
+        }
       } else if (msg.type === 'hmr:reload') {
         var ds = g.__turboModuleProxy ? g.__turboModuleProxy('DevSettings') : null;
         if (ds && ds.reload) ds.reload();
@@ -470,7 +482,7 @@ try {
   };
   __hmrWS.onopen = function() {
     if (typeof __rolldown_runtime__ !== 'undefined' && __rolldown_runtime__.setup) {
-      __rolldown_runtime__.setup(__hmrWS, __hmrUrl.replace('ws://', 'http://'));
+      __rolldown_runtime__.setup(__hmrWS);
     }
   };
   __hmrWS.onerror = function(e) { console.warn('[vxrn] HMR connection error:', e.message || e); };
@@ -515,38 +527,36 @@ try {
         onHmrUpdate?.({ type: 'hmr:error' })
         return
       }
-      const updates = (result as any).updates || []
-      for (const item of updates) {
-        const update = item.update || item
+      for (const { clientId, update } of result.updates) {
         if (update.type === 'Patch' && update.code) {
-          onHmrUpdate?.({ type: 'hmr:update', code: update.code })
+          onHmrUpdate?.({
+            type: 'hmr:update',
+            clientId,
+            code: update.code,
+            changedIds: update.changedIds,
+            seq: update.seq,
+          })
         } else if (update.type === 'FullReload') {
-          onHmrUpdate?.({ type: 'hmr:reload' })
+          onHmrUpdate?.({ type: 'hmr:reload', clientId })
         }
       }
-
-      if (updates.length === 0) {
-        onHmrUpdate?.({ type: 'hmr:reload' })
-      }
     },
 
-    // rolldown 1.2 dropped 'auto': the server no longer decides full reloads,
-    // so callers pull fresh output explicitly instead. getBundle() below
-    // already awaits ensureLatestBuildOutput(), which is that explicit pull,
-    // so 'never' keeps the same behavior without rebuilding on every hmr patch.
+    // patches update the registered client runtime directly. a full bundle rebuild
+    // is only needed when the runtime requests a reload.
     rebuildStrategy: 'never',
     watch: {},
   })
 
   await engine.run()
 
-  // modules are registered via WebSocket messages from the HMR client
-  // (the devMode runtime sends hmr:module-registered messages)
-
   return {
     engine,
 
     async getBundle() {
+      // a runtime invalidation marks the full output stale before reloading. pull
+      // that output before serving the cached bundle to the restarted app.
+      await engine.ensureLatestBuildOutput()
       if (currentBundle) return currentBundle
       if (!bundlePromise) {
         let timeoutId: ReturnType<typeof setTimeout>
@@ -561,8 +571,6 @@ try {
           )
         })
       }
-      await engine.ensureLatestBuildOutput()
-      if (currentBundle) return currentBundle
       return bundlePromise
     },
 
@@ -889,7 +897,11 @@ function cssStubPlugin(): Plugin {
  * react-native codegen, react compiler, and react-refresh (dev only) —
  * same pipeline as metro, single babel pass per file.
  */
-export function vxrnCompilerPlugin(platform: string, dev: boolean): Plugin {
+export function vxrnCompilerPlugin(
+  platform: string,
+  dev: boolean,
+  projectRoot = process.cwd()
+): Plugin {
   let compiler: typeof import('@vxrn/compiler') | null = null
 
   // whether a file is a user file that should get react-refresh wiring
@@ -913,6 +925,7 @@ export function vxrnCompilerPlugin(platform: string, dev: boolean): Plugin {
         const props = {
           id,
           code,
+          projectRoot,
           development: dev,
           environment: platform as 'ios' | 'android',
           reactForRNVersion: '19' as const,
@@ -1145,33 +1158,40 @@ function hermesCompatSWCPlugin(dev: boolean): Plugin {
 
 // --- HMR runtime ---
 
-function getHmrRuntimeSource(): string {
+export function getHmrRuntimeSource(): string {
   return `
 // vxrn HMR runtime for rolldown devMode
 var BaseDevRuntime = DevRuntime;
 
 class ReactNativeDevRuntime extends BaseDevRuntime {
   constructor() {
-    var _shared = { _socket: null, _queue: [] };
     var clientId = 'rn-' + Date.now() + '-' + Math.random().toString(36).slice(2);
-    super({ send: function(msg) {
-      var s = JSON.stringify(msg);
-      if (_shared._socket && _shared._socket.readyState === 1) { _shared._socket.send(s); }
-      else { _shared._queue.push(s); }
-    }}, clientId);
-    this._shared = _shared;
+    super(clientId);
     this._socket = null;
-    this._queue = [];
     this.moduleHotContexts = {};
+    this.lastSeq = 0;
   }
 
   createModuleHotContext(moduleId) {
+    var runtime = this;
     var ctx = {
       acceptCallbacks: [],
-      accept: function(cb) {
-        if (cb) ctx.acceptCallbacks.push({ deps: [moduleId], fn: cb });
+      accept: function(deps, callback) {
+        if (typeof deps === 'function' || !deps) {
+          ctx.acceptCallbacks.push({
+            deps: [moduleId],
+            fn: function(modules) { if (typeof deps === 'function') deps(modules[0]); }
+          });
+        } else if (typeof deps === 'string') {
+          ctx.acceptCallbacks.push({
+            deps: [deps],
+            fn: function(modules) { if (callback) callback(modules[0]); }
+          });
+        } else if (Array.isArray(deps)) {
+          ctx.acceptCallbacks.push({ deps: deps, fn: callback || function() {} });
+        }
       },
-      invalidate: function() {},
+      invalidate: function() { runtime.requestReload('module invalidated: ' + moduleId); },
       on: function() {},
       off: function() {},
       send: function() {},
@@ -1202,55 +1222,112 @@ class ReactNativeDevRuntime extends BaseDevRuntime {
     return ctx;
   }
 
-  applyUpdates(boundaries) {
-    for (var i = 0; i < boundaries.length; i++) {
-      var moduleId = boundaries[i][0];
-      var ctx = this.moduleHotContexts[moduleId];
-      if (ctx && ctx.acceptCallbacks) {
-        for (var j = 0; j < ctx.acceptCallbacks.length; j++) {
-          ctx.acceptCallbacks[j].fn(this.modules[moduleId].exports);
-        }
+  isSelfAccepted(moduleId) {
+    var ctx = this.moduleHotContexts[moduleId];
+    return !!(ctx && ctx.acceptCallbacks.some(function(callback) {
+      return callback.deps.indexOf(moduleId) !== -1;
+    }));
+  }
+
+  acceptsDependency(parentId, moduleId) {
+    var ctx = this.moduleHotContexts[parentId];
+    return !!(ctx && ctx.acceptCallbacks.some(function(callback) {
+      return callback.deps.indexOf(moduleId) !== -1;
+    }));
+  }
+
+  findBoundaries(moduleId, traversed, updateSet, boundaries) {
+    if (traversed.has(moduleId)) return true;
+    traversed.add(moduleId);
+    updateSet.add(moduleId);
+
+    if (this.isSelfAccepted(moduleId)) {
+      boundaries.push({ boundary: moduleId, acceptedVia: moduleId });
+      return true;
+    }
+
+    var importers = this.getImporters(moduleId).filter(function(importer) {
+      return this.isExecuted(importer);
+    }, this);
+    if (importers.length === 0) return false;
+
+    for (var i = 0; i < importers.length; i++) {
+      var importer = importers[i];
+      if (this.acceptsDependency(importer, moduleId)) {
+        boundaries.push({ boundary: importer, acceptedVia: moduleId });
+      } else if (!this.findBoundaries(importer, traversed, updateSet, boundaries)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  applyHmrUpdate(code, changedIds, seq) {
+    if (seq !== this.lastSeq + 1) return false;
+    this.lastSeq = seq;
+
+    var traversed = new Set();
+    var updateSet = new Set();
+    var boundaries = [];
+    for (var i = 0; i < changedIds.length; i++) {
+      var changedId = changedIds[i];
+      if (!this.isExecuted(changedId)) continue;
+      if (!this.findBoundaries(changedId, traversed, updateSet, boundaries)) return false;
+    }
+    if (boundaries.length === 0) return true;
+
+    var callbacks = boundaries.map(function(item) {
+      var ctx = this.moduleHotContexts[item.boundary];
+      return {
+        boundary: item.boundary,
+        acceptedVia: item.acceptedVia,
+        callbacks: ctx ? ctx.acceptCallbacks.filter(function(callback) {
+          return callback.deps.indexOf(item.acceptedVia) !== -1;
+        }) : []
+      };
+    }, this);
+
+    if (globalThis.globalEvalWithSourceUrl) globalThis.globalEvalWithSourceUrl(code);
+    else (0, eval)(code);
+
+    var modulesToReplace = Array.from(updateSet);
+    for (var j = 0; j < modulesToReplace.length; j++) {
+      if (!this.hasFactory(modulesToReplace[j])) return false;
+    }
+    for (var k = 0; k < modulesToReplace.length; k++) {
+      this.removeModuleCache(modulesToReplace[k]);
+    }
+
+    for (var m = 0; m < callbacks.length; m++) {
+      var apply = callbacks[m];
+      this.initModule(apply.acceptedVia);
+      var freshExports = this.loadExports(apply.acceptedVia);
+      for (var n = 0; n < apply.callbacks.length; n++) {
+        apply.callbacks[n].fn([freshExports]);
       }
-      // surface each committed module id to the framework hot-update hook (if one
-      // is registered). RN's React Refresh can't repaint frameworks that re-wrap
-      // route components away from the edited module's Refresh family (e.g. One),
-      // and the web route-update event has no equivalent on the native /hot
-      // socket, so this generic vxrn global is the bridge.
+    }
+
+    for (var p = 0; p < changedIds.length; p++) {
       try {
-        if (globalThis.__VXRN_ON_MODULE_UPDATED__ && moduleId) globalThis.__VXRN_ON_MODULE_UPDATED__(moduleId);
+        if (globalThis.__VXRN_ON_MODULE_UPDATED__) {
+          globalThis.__VXRN_ON_MODULE_UPDATED__(changedIds[p]);
+        }
       } catch (error) {
         console.error('[vxrn HMR]: module update hook failed', error);
       }
     }
+    return true;
   }
 
-  setup(socket, origin) {
-    if (this._socket) return;
-    this._socket = socket;
-    // also set the shared messenger socket so queued messages can flush
-    if (this._shared) this._shared._socket = socket;
-
-    var flushQueues = function() {
-      // flush messenger queue
-      if (this._shared && this._shared._queue.length) {
-        for (var i = 0; i < this._shared._queue.length; i++) socket.send(this._shared._queue[i]);
-        this._shared._queue = [];
-      }
-      // flush instance queue
-      for (var i = 0; i < this._queue.length; i++) socket.send(this._queue[i]);
-      this._queue = [];
-    }.bind(this);
-
-    if (socket.readyState === 1) {
-      flushQueues();
-    } else {
-      socket.addEventListener('open', function() {
-        flushQueues();
-      }, { once: true });
+  requestReload(reason) {
+    if (this._socket && this._socket.readyState === 1) {
+      this._socket.send(JSON.stringify({ type: 'hmr:invalidate', reason: reason }));
     }
+  }
 
-    // HMR message handling is done by the outro WebSocket handler
-    // the runtime's setup() only needs to flush queued messages
+  setup(socket) {
+    if (this._socket) return;
+    this._socket = socket;
   }
 }
 

package/types/utils/createNativeDevEngine.d.ts

@@ -6,6 +6,7 @@
  * https://github.com/leegeunhyeok/rollipop
  */
 import type { Plugin } from 'rolldown';
+import type { DevEngine } from 'rolldown/experimental';
 /** SWC `env.include` for Hermes-compatible downleveling; see HERMES_CLASS_TRANSFORMS. */
 export declare function getHermesSWCIncludes(dev: boolean): string[];
 interface NativeDevEngineOptions {
@@ -15,13 +16,22 @@ interface NativeDevEngineOptions {
     platform: 'ios' | 'android';
     serverUrl?: string;
     plugins?: Plugin[];
-    onHmrUpdate?: (update: {
-        type: string;
-        code?: string;
-    }) => void;
+    onHmrUpdate?: (update: NativeHmrUpdate) => void;
 }
+export type NativeHmrUpdate = {
+    type: 'hmr:update';
+    clientId: string;
+    code: string;
+    changedIds: string[];
+    seq: number;
+} | {
+    type: 'hmr:reload';
+    clientId: string;
+} | {
+    type: 'hmr:error';
+};
 interface NativeDevEngineResult {
-    engine: any;
+    engine: DevEngine;
     getBundle: () => Promise<{
         code: string;
     }>;
@@ -102,6 +112,7 @@ export declare function hmrClientNoopPlugin(): Plugin;
  * react-native codegen, react compiler, and react-refresh (dev only) —
  * same pipeline as metro, single babel pass per file.
  */
-export declare function vxrnCompilerPlugin(platform: string, dev: boolean): Plugin;
+export declare function vxrnCompilerPlugin(platform: string, dev: boolean, projectRoot?: string): Plugin;
+export declare function getHmrRuntimeSource(): string;
 export {};
 //# sourceMappingURL=createNativeDevEngine.d.ts.map