vxrn 1.25.5 → 1.25.7

package/dist/utils/createNativeDevEngine.mjs

@@ -0,0 +1,939 @@
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { normalizePath } from "vite";
+import { DEFAULT_ASSET_EXTS } from "../constants/defaults.mjs";
+import { getNativePrelude } from "../runtime/native-prelude.mjs";
+const FLOW_FILE_PATTERN = /node_modules[\\/](?:react-native|@react-native)[\\/].*\.js$/;
+const HERMES_CLASS_TRANSFORMS = ["transform-classes", "transform-class-properties", "transform-class-static-block", "transform-private-methods", "transform-private-property-in-object"];
+const HERMES_PROD_TRANSFORMS = ["transform-async-to-generator"];
+function getHermesSWCIncludes(dev) {
+  return [...HERMES_CLASS_TRANSFORMS, ...(dev ? [] : HERMES_PROD_TRANSFORMS)];
+}
+function getResolveExtensions(platform) {
+  const platformExts = platform === "ios" ? [".ios.tsx", ".ios.ts", ".ios.jsx", ".ios.js"] : [".android.tsx", ".android.ts", ".android.jsx", ".android.js"];
+  const nativeExts = [".native.tsx", ".native.ts", ".native.jsx", ".native.js"];
+  const defaultExts = [".tsx", ".ts", ".jsx", ".js", ".mjs", ".cjs", ".json"];
+  return [...platformExts, ...nativeExts, ...defaultExts];
+}
+function getNativeResolveConfig(platform) {
+  return {
+    extensions: getResolveExtensions(platform),
+    conditionNames: ["react-native", "import", "require", "default"],
+    mainFields: ["react-native", "module", "main"]
+  };
+}
+function getNativeTransformConfig(platform, dev, root) {
+  const entryConfig = globalThis.__vxrnNativeEntryConfig || {};
+  const setupFileDefines = (() => {
+    const sf = entryConfig.setupFile;
+    if (!sf) return {};
+    const files = typeof sf === "string" ? {
+      client: sf,
+      server: sf,
+      ios: sf,
+      android: sf
+    } : "native" in sf ? {
+      client: sf.client,
+      server: sf.server,
+      ios: sf.native,
+      android: sf.native
+    } : sf;
+    return {
+      ...(files.client && {
+        "process.env.ONE_SETUP_FILE_CLIENT": JSON.stringify(files.client)
+      }),
+      ...(files.server && {
+        "process.env.ONE_SETUP_FILE_SERVER": JSON.stringify(files.server)
+      }),
+      ...(files.ios && {
+        "process.env.ONE_SETUP_FILE_IOS": JSON.stringify(files.ios)
+      }),
+      ...(files.android && {
+        "process.env.ONE_SETUP_FILE_ANDROID": JSON.stringify(files.android)
+      })
+    };
+  })();
+  const envDefines = (() => {
+    const defines = {};
+    try {
+      const mode2 = dev ? "development" : "production";
+      for (const envFile of [".env", ".env.local", `.env.${mode2}`, `.env.${mode2}.local`]) {
+        const envPath = join(root, envFile);
+        if (!existsSync(envPath)) continue;
+        const content = readFileSync(envPath, "utf8");
+        for (const line of content.split("\n")) {
+          const match = line.match(/^\s*(VITE_\w+)\s*=\s*(.*)$/);
+          if (match) {
+            const [, key, rawVal] = match;
+            const val = rawVal.replace(/^['"]|['"]$/g, "").trim();
+            defines[`import.meta.env.${key}`] = JSON.stringify(val);
+            defines[`process.env.${key}`] = JSON.stringify(val);
+          }
+        }
+      }
+    } catch {}
+    return defines;
+  })();
+  const mode = dev ? "development" : "production";
+  const envObject = {
+    MODE: mode,
+    DEV: dev,
+    PROD: !dev,
+    SSR: false,
+    VITE_ENVIRONMENT: platform,
+    VITE_NATIVE: "1",
+    EXPO_OS: platform,
+    TAMAGUI_TARGET: "native",
+    TAMAGUI_ENVIRONMENT: platform
+  };
+  for (const [key, val] of Object.entries(envDefines)) {
+    const match = key.match(/^import\.meta\.env\.(.+)$/);
+    if (match) try {
+      envObject[match[1]] = JSON.parse(val);
+    } catch {
+      envObject[match[1]] = val;
+    }
+  }
+  return {
+    jsx: {
+      runtime: "classic"
+    },
+    define: {
+      "process.env.NODE_ENV": JSON.stringify(mode),
+      "process.env.VXRN_REACT_19": "false",
+      "process.env.VITE_ENVIRONMENT": JSON.stringify(platform),
+      "process.env.VITE_NATIVE": "\"1\"",
+      "process.env.EXPO_OS": JSON.stringify(platform),
+      "process.env.TAMAGUI_TARGET": "\"native\"",
+      "process.env.TAMAGUI_ENVIRONMENT": JSON.stringify(platform),
+      __DEV__: dev ? "true" : "false",
+      "import.meta.env": JSON.stringify(envObject),
+      "import.meta.env.MODE": JSON.stringify(mode),
+      "import.meta.env.DEV": dev ? "true" : "false",
+      "import.meta.env.PROD": dev ? "false" : "true",
+      "import.meta.env.SSR": "false",
+      "import.meta.env.VITE_ENVIRONMENT": JSON.stringify(platform),
+      "import.meta.env.VITE_NATIVE": "\"1\"",
+      "import.meta.env.EXPO_OS": JSON.stringify(platform),
+      "import.meta.env.TAMAGUI_TARGET": "\"native\"",
+      "import.meta.env.TAMAGUI_ENVIRONMENT": JSON.stringify(platform),
+      ...envDefines,
+      ...setupFileDefines
+    },
+    inject: {
+      React: "react"
+    }
+  };
+}
+function getNativePlugins(root, platform, viteImportGlobPlugin, dev, assetsDest) {
+  return [...(globalThis.__vxrnAddNativePlugins || []), serverFileExclusionPlugin(), environmentGuardPlugin(), hmrClientNoopPlugin(), cssStubPlugin(), viteImportGlobPlugin({
+    root
+  }), vxrnCompilerPlugin(platform, dev, root), flowStripPlugin(), nativeAnimatedGuardPlugin(), assetPlugin({
+    root,
+    platform,
+    assetsDest
+  }), hermesCompatSWCPlugin(dev)];
+}
+function getNativeOutputOptions(prelude, sourcemap) {
+  return {
+    format: "esm",
+    sourcemap,
+    intro: prelude,
+    codeSplitting: false,
+    strictExecutionOrder: true
+  };
+}
+function postProcessNativeBundle(code) {
+  code = code.replace(/^\s*export\s*\{[^}]*\}\s*;?\s*$/gm, "");
+  code = code.replace(/^\s*export\s+default\s+([^;\n]+);?\s*$/gm, "$1;");
+  code = code.replace(/^if \(import\.meta\.hot\).*$/gm, "");
+  {
+    const idx = code.indexOf("NativeAnimatedModule_default ?? NativeAnimatedTurboModule_default;");
+    if (idx !== -1) {
+      const beforeMarker = code.lastIndexOf("NativeAnimatedModule = ", idx);
+      if (beforeMarker !== -1) {
+        const lineStart = code.lastIndexOf("\n", beforeMarker);
+        const snippet = code.slice(lineStart + 1, beforeMarker + 50);
+        if (snippet.includes("(function()") || snippet.includes("new Proxy")) {
+          const afterMarker = code.indexOf("})();", idx);
+          if (afterMarker !== -1) {
+            const end = afterMarker + 5;
+            code = code.slice(0, beforeMarker) + "NativeAnimatedModule = NativeAnimatedModule_default ?? NativeAnimatedTurboModule_default;" + code.slice(end);
+          }
+        }
+      }
+    }
+  }
+  return code;
+}
+function wrapNativeBundleModuleScope(code) {
+  const idx = code.indexOf("//#region \\0rolldown/runtime.js");
+  if (idx === -1) return code;
+  return code.slice(0, idx) + ";(function() {\n" + code.slice(idx) + "\n})();\n";
+}
+async function downlevelClassFieldsInBundle(code) {
+  const startMarker = "//#region \\0rolldown/runtime.js";
+  const endMarker = "//#endregion";
+  const startIdx = code.indexOf(startMarker);
+  if (startIdx === -1) return code;
+  const endIdx = code.indexOf(endMarker, startIdx);
+  if (endIdx === -1) return code;
+  const runtimeEnd = endIdx + 12;
+  const runtimeSection = code.slice(startIdx, runtimeEnd);
+  try {
+    const result = await (await import("@swc/core")).transform(runtimeSection, {
+      filename: "rolldown-runtime.js",
+      configFile: false,
+      swcrc: false,
+      sourceMaps: false,
+      inputSourceMap: false,
+      isModule: false,
+      env: {
+        targets: {
+          node: 9999
+        },
+        include: [...HERMES_CLASS_TRANSFORMS]
+      },
+      jsc: {
+        parser: {
+          syntax: "ecmascript"
+        },
+        transform: {
+          react: {
+            runtime: "preserve"
+          }
+        },
+        externalHelpers: false,
+        assumptions: {
+          setPublicClassFields: true,
+          privateFieldsAsProperties: true
+        }
+      }
+    });
+    return code.slice(0, startIdx) + result.code + code.slice(runtimeEnd);
+  } catch (err) {
+    console.warn("[vxrn] downlevelClassFieldsInBundle failed, returning original:", err);
+    return code;
+  }
+}
+async function createNativeDevEngine(options) {
+  const {
+    root,
+    port,
+    host = "localhost",
+    platform,
+    serverUrl,
+    plugins: userPlugins = [],
+    onHmrUpdate
+  } = options;
+  const {
+    dev,
+    viteImportGlobPlugin
+  } = await import("rolldown/experimental");
+  const hmrRuntimeSource = getHmrRuntimeSource();
+  const prelude = getNativePrelude({
+    dev: true,
+    platform,
+    serverUrl: serverUrl || `http://${host}:${port}`
+  });
+  let currentBundle = null;
+  let bundleResolve = null;
+  let bundlePromise = null;
+  const resolvedHost = host === "0.0.0.0" ? "localhost" : host;
+  const engine = await dev({
+    input: VIRTUAL_NATIVE_ENTRY,
+    cwd: root,
+    platform: "neutral",
+    resolve: getNativeResolveConfig(platform),
+    transform: getNativeTransformConfig(platform, true, root),
+    experimental: {
+      devMode: {
+        implement: hmrRuntimeSource,
+        host,
+        port
+      },
+      incrementalBuild: true,
+      lazyBarrel: true
+    },
+    treeshake: false,
+    shimMissingExports: true,
+    moduleTypes: {
+      ".js": "jsx"
+    },
+    plugins: [nativeVirtualEntryPlugin(root, {
+      dev: true
+    }), ...getNativePlugins(root, platform, viteImportGlobPlugin, true), ...userPlugins]
+  }, {
+    ...getNativeOutputOptions(prelude, false),
+    outro: `
+try {
+  var __WS = (init_WebSocket(), __toCommonJS(WebSocket_exports)).default;
+  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) {
+        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();
+      }
+    } catch(e) { console.error('[vxrn] HMR eval error:', e); }
+  };
+  __hmrWS.onopen = function() {
+    if (typeof __rolldown_runtime__ !== 'undefined' && __rolldown_runtime__.setup) {
+      __rolldown_runtime__.setup(__hmrWS);
+    }
+  };
+  __hmrWS.onerror = function(e) { console.warn('[vxrn] HMR connection error:', e.message || e); };
+} catch(e) {}
+`
+  }, {
+    onOutput: async result => {
+      if (result instanceof Error) {
+        console.error("[vxrn] native bundle error:", result.message);
+        return;
+      }
+      const chunk = result.output.find(o => o.type === "chunk" && o.isEntry);
+      if (chunk && "code" in chunk) {
+        let code = postProcessNativeBundle(chunk.code);
+        code = await downlevelClassFieldsInBundle(code);
+        code = wrapNativeBundleModuleScope(code);
+        currentBundle = {
+          code
+        };
+        console.info(`[vxrn] native bundle ready (${Math.round(code.length / 1024)}KB)`);
+        if (bundleResolve) {
+          bundleResolve(currentBundle);
+          bundleResolve = null;
+          bundlePromise = null;
+        }
+      }
+    },
+    onHmrUpdates: async result => {
+      if (result instanceof Error) {
+        console.error("[vxrn] HMR error:", result.message);
+        onHmrUpdate?.({
+          type: "hmr:error"
+        });
+        return;
+      }
+      for (const {
+        clientId,
+        update
+      } of result.updates) if (update.type === "Patch" && 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",
+        clientId
+      });
+    },
+    rebuildStrategy: "never",
+    watch: {}
+  });
+  await engine.run();
+  return {
+    engine,
+    async getBundle() {
+      await engine.ensureLatestBuildOutput();
+      if (currentBundle) return currentBundle;
+      if (!bundlePromise) {
+        let timeoutId;
+        bundlePromise = new Promise((resolve2, reject) => {
+          bundleResolve = value => {
+            clearTimeout(timeoutId);
+            resolve2(value);
+          };
+          timeoutId = setTimeout(() => reject(/* @__PURE__ */new Error("[vxrn] bundle build timed out after 120s")), 12e4);
+        });
+      }
+      return bundlePromise;
+    },
+    async close() {
+      await engine.close();
+    }
+  };
+}
+async function buildNativeBundle(options) {
+  const {
+    root,
+    platform,
+    dev = false,
+    serverUrl,
+    entryFile,
+    assetsDest,
+    plugins: userPlugins = [],
+    sourcemap = false
+  } = options;
+  const {
+    build
+  } = await import("rolldown");
+  const {
+    viteImportGlobPlugin
+  } = await import("rolldown/experimental");
+  const prelude = getNativePrelude({
+    dev,
+    platform,
+    serverUrl
+  });
+  const chunk = (await build({
+    input: entryFile ? normalizePath(resolve(root, entryFile)) : VIRTUAL_NATIVE_ENTRY,
+    cwd: root,
+    platform: "neutral",
+    resolve: getNativeResolveConfig(platform),
+    transform: getNativeTransformConfig(platform, dev, root),
+    treeshake: !dev,
+    experimental: {
+      lazyBarrel: false
+    },
+    shimMissingExports: true,
+    moduleTypes: {
+      ".js": "jsx"
+    },
+    plugins: [...(entryFile ? [] : [nativeVirtualEntryPlugin(root, {
+      dev
+    })]), ...getNativePlugins(root, platform, viteImportGlobPlugin, dev, assetsDest), ...userPlugins],
+    output: getNativeOutputOptions(prelude, sourcemap)
+  })).output.find(o => o.type === "chunk" && o.isEntry);
+  if (!chunk || !("code" in chunk)) throw new Error("[vxrn] production build produced no output");
+  let code = postProcessNativeBundle(chunk.code);
+  code = await downlevelClassFieldsInBundle(code);
+  return {
+    code,
+    map: sourcemap ? chunk.map?.toString() : void 0
+  };
+}
+const VIRTUAL_NATIVE_ENTRY = "virtual:native-entry";
+function nativeVirtualEntryPlugin(root, opts) {
+  const isDev = opts?.dev !== false;
+  const resolvedId = normalizePath(resolve(root, "__virtual-native-entry.tsx"));
+  const entryConfig = globalThis.__vxrnNativeEntryConfig || {};
+  const routerRoot = entryConfig.routerRoot || "app";
+  const flags = entryConfig.flags || {};
+  const linking = entryConfig.linking;
+  const setupFileImport = (() => {
+    const sf = entryConfig.setupFile;
+    if (!sf) return "";
+    const file = typeof sf === "string" ? sf : "native" in sf ? sf.native : sf.ios;
+    if (!file) return "";
+    const resolved = pathToFileURL(resolve(root, file)).href;
+    return `import ${JSON.stringify(resolved)};`;
+  })();
+  const routeGlobs = [`./${routerRoot}/**/*.tsx`, `./${routerRoot}/**/*.ts`, `!./${routerRoot}/**/*+api.*`, `!./${routerRoot}/**/*.test.*`, `!./${routerRoot}/**/*.d.ts`, `!./${routerRoot}/**/*.server.*`, `!./${routerRoot}/**/_middleware.*`, `!./${routerRoot}/**/*.web.*`, ...(entryConfig.ignoredRouteFiles || []).map(pattern => `!./${routerRoot}/${pattern}`)];
+  const entryCode = `
+${isDev ? `
+// react-refresh/runtime MUST initialize before React loads
+import RefreshRuntime from 'react-refresh/runtime';
+RefreshRuntime.injectIntoGlobalHook(globalThis);
+globalThis.__ReactRefresh = RefreshRuntime;
+globalThis.$RefreshReg$ = function(type, id) {
+  RefreshRuntime.register(type, id);
+};
+globalThis.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
+` : ""}
+import * as ReactNativeInitializeCore from 'react-native/Libraries/Core/InitializeCore';
+import NativeWebSocket from 'react-native/Libraries/WebSocket/WebSocket';
+${setupFileImport}
+import { createApp } from 'one';
+
+void ReactNativeInitializeCore;
+globalThis.WebSocket = NativeWebSocket;
+
+var _routes = import.meta.glob(${JSON.stringify(routeGlobs)}, { exhaustive: true });
+// fix route keys: One expects '/${routerRoot}/...' prefix but import.meta.glob returns './${routerRoot}/...'
+var routes = {};
+Object.keys(_routes).forEach(function(key) {
+  var normalizedKey = key.replace(/^\\.\\//, '');
+  routes['/' + normalizedKey] = _routes[key];
+});
+
+createApp({
+  routes: routes,
+  routerRoot: ${JSON.stringify(routerRoot)},
+  flags: ${JSON.stringify(flags)},
+  linking: ${JSON.stringify(linking)},
+});
+`;
+  return {
+    name: "vxrn:native-virtual-entry",
+    resolveId(id) {
+      if (id === VIRTUAL_NATIVE_ENTRY) return resolvedId;
+    },
+    load(id) {
+      if (id === resolvedId) return entryCode;
+    }
+  };
+}
+function nativeAnimatedGuardPlugin() {
+  return {
+    name: "vxrn:native-animated-guard",
+    transform(code, id) {
+      if (!id.includes("animated/NativeAnimatedHelper")) return;
+      const target = "const method = nullthrows(NativeAnimatedModule)[methodName];";
+      if (!code.includes(target)) return;
+      return {
+        code: code.replace(target, `const method = nullthrows(NativeAnimatedModule)[methodName];
+        if (typeof method !== 'function') return;`)
+      };
+    }
+  };
+}
+function serverFileExclusionPlugin() {
+  return {
+    name: "vxrn:server-file-exclusion",
+    load(id) {
+      if (/\.server\.\w+$/.test(id)) return {
+        code: "export default undefined;",
+        moduleType: "js"
+      };
+      if (/[\\/]_middleware\.\w+$/.test(id)) return {
+        code: "export default undefined;",
+        moduleType: "js"
+      };
+    }
+  };
+}
+function environmentGuardPlugin() {
+  const THROWING = ["server-only", "client-only", "web-only"];
+  const NOOP = ["native-only"];
+  return {
+    name: "vxrn:environment-guard",
+    resolveId(source) {
+      if (THROWING.includes(source)) return {
+        id: `\0env-guard-throw:${source}`,
+        external: false
+      };
+      if (NOOP.includes(source)) return {
+        id: `\0env-guard-noop:${source}`,
+        external: false
+      };
+    },
+    load(id) {
+      if (id.startsWith("\0env-guard-throw:")) return {
+        code: `throw new Error("Cannot import '${id.slice(17)}' in a native bundle.");`,
+        moduleType: "js"
+      };
+      if (id.startsWith("\0env-guard-noop:")) return {
+        code: "",
+        moduleType: "js"
+      };
+    }
+  };
+}
+function hmrClientNoopPlugin() {
+  const RN_HMR_CLIENT_RE = /(^|[\\/])Utilities[\\/]HMRClient(\.[cm]?[jt]sx?)?$/;
+  return {
+    name: "vxrn:hmr-client-noop",
+    resolveId(source, importer) {
+      if ((source.startsWith("react-native/") || importer != null && /(^|[\\/])react-native[\\/]/.test(importer)) && RN_HMR_CLIENT_RE.test(source)) return {
+        id: "\0vxrn-hmr-client-noop",
+        external: false
+      };
+    },
+    load(id) {
+      if (id === "\0vxrn-hmr-client-noop") return {
+        code: `const HMRClient = { setup() {}, enable() {}, disable() {}, registerBundle() {}, log() {}, isEnabled() { return false } }
+export default HMRClient`,
+        moduleType: "js"
+      };
+    }
+  };
+}
+function cssStubPlugin() {
+  return {
+    name: "vxrn:css-stub",
+    load: {
+      handler(id) {
+        if (id.endsWith(".css")) return {
+          code: "",
+          moduleType: "js"
+        };
+      }
+    }
+  };
+}
+function vxrnCompilerPlugin(platform, dev, projectRoot = process.cwd()) {
+  let compiler = null;
+  const isRefreshCandidate = id => dev && !id.includes("node_modules") && !id.includes("__virtual-native-entry") && /\.[tj]sx?$/.test(id);
+  return {
+    name: "vxrn:compiler",
+    async transform(code, id) {
+      if (!/\.[cm]?[jt]sx?$/.test(id)) return;
+      if (id.includes("\0") || id.includes("virtual:")) return;
+      const needsRefresh = isRefreshCandidate(id);
+      try {
+        if (!compiler) compiler = await import("@vxrn/compiler");
+        const props = {
+          id,
+          code,
+          projectRoot,
+          development: dev,
+          environment: platform,
+          reactForRNVersion: "19"
+        };
+        let babelOptions = compiler.getBabelOptions(props);
+        if (needsRefresh) {
+          const existingPlugins = babelOptions?.plugins || [];
+          babelOptions = {
+            ...babelOptions,
+            plugins: [...existingPlugins, ["react-refresh/babel", {
+              skipEnvCheck: true,
+              refreshReg: "__vxrnRefreshReg",
+              refreshSig: "__vxrnRefreshSig"
+            }]]
+          };
+        }
+        if (!babelOptions) return;
+        const result = await compiler.transformBabel(id, code, babelOptions);
+        if (result?.code) {
+          let out = result.code;
+          if (needsRefresh) out = `
+var __prevRefreshReg = globalThis.$RefreshReg$;
+var __prevRefreshSig = globalThis.$RefreshSig$;
+if (globalThis.__ReactRefresh) {
+  globalThis.$RefreshReg$ = function(type, id) {
+    globalThis.__ReactRefresh.register(type, "${id.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}" + " " + id);
+  };
+  globalThis.$RefreshSig$ = globalThis.__ReactRefresh.createSignatureFunctionForTransform;
+}
+// keep registration calls local so rolldown retains them in the initial bundle.
+var __vxrnRefreshReg = globalThis.$RefreshReg$;
+var __vxrnRefreshSig = globalThis.$RefreshSig$;
+
+${out}
+
+globalThis.$RefreshReg$ = __prevRefreshReg;
+globalThis.$RefreshSig$ = __prevRefreshSig;
+if (import.meta.hot) {
+  import.meta.hot.accept(function() {
+    if (globalThis.__ReactRefresh) {
+      setTimeout(function() { globalThis.__ReactRefresh.performReactRefresh(); }, 30);
+    }
+  });
+}
+`;
+          return {
+            code: out
+          };
+        }
+      } catch (err) {
+        if (dev) console.warn(`[vxrn:compiler] ${id}: ${err.message || err}`);
+        if (needsRefresh) return {
+          code: code + `
+if (import.meta.hot) { import.meta.hot.accept(); }
+`
+        };
+      }
+    }
+  };
+}
+function flowStripPlugin() {
+  return {
+    name: "vxrn:flow-strip",
+    transform: {
+      async handler(code, id) {
+        if (!FLOW_FILE_PATTERN.test(id)) return;
+        try {
+          const result = await (await import("fast-flow-transform")).default({
+            filename: id,
+            source: code,
+            sourcemap: true,
+            dialect: "flow",
+            format: "pretty"
+          });
+          return {
+            code: result.code,
+            map: result.map
+          };
+        } catch (err) {
+          console.warn(`[vxrn:flow-strip] ${id}: ${err.message}`);
+        }
+      }
+    }
+  };
+}
+function assetPlugin(opts) {
+  const assetRegex = new RegExp(`\\.(?:${DEFAULT_ASSET_EXTS.join("|")})$`);
+  return {
+    name: "vxrn:asset",
+    load: {
+      async handler(id) {
+        if (!assetRegex.test(id)) return;
+        const ext = extname(id).slice(1);
+        const name = basename(id, `.${ext}`);
+        const dir = dirname(id);
+        const relativePath = relative(opts.root, id);
+        const assetData = {
+          __packager_asset: true,
+          name,
+          type: ext,
+          scales: [1],
+          httpServerLocation: "/assets/" + dirname(relativePath).replace(/\\/g, "/"),
+          fileSystemLocation: dir,
+          hash: "",
+          width: void 0,
+          height: void 0
+        };
+        if (["png", "jpg", "jpeg", "gif", "webp", "bmp"].includes(ext)) try {
+          const {
+            imageSize
+          } = await import("image-size");
+          const dims = imageSize(id);
+          assetData.width = dims.width;
+          assetData.height = dims.height;
+        } catch {}
+        if (opts.assetsDest) {
+          const relativeAssetDir = dirname(relativePath).replace(/\\/g, "/");
+          const assetDestDir = join(opts.assetsDest, "assets", relativeAssetDir);
+          mkdirSync(assetDestDir, {
+            recursive: true
+          });
+          copyFileSync(id, join(assetDestDir, `${name}.${ext}`));
+        }
+        return {
+          code: `module.exports = require('react-native/Libraries/Image/AssetRegistry').registerAsset(${JSON.stringify(assetData)});`,
+          moduleType: "js"
+        };
+      }
+    }
+  };
+}
+function hermesCompatSWCPlugin(dev) {
+  let swc = null;
+  return {
+    name: "vxrn:hermes-compat",
+    async transform(code, id) {
+      if (!/\.[cm]?[jt]sx?$/.test(id)) return;
+      if (id.includes("\0") || id.includes("virtual:")) return;
+      const hasClass = code.includes("class ") || code.includes("class{");
+      const hasAsync = !dev && code.includes("async ");
+      if (!hasClass && !hasAsync) return;
+      if (code.length > 5e5) return;
+      try {
+        if (!swc) swc = await import("@swc/core");
+        const envIncludes = getHermesSWCIncludes(dev);
+        return {
+          code: (await swc.transform(code, {
+            filename: id,
+            configFile: false,
+            swcrc: false,
+            sourceMaps: false,
+            inputSourceMap: false,
+            env: {
+              targets: {
+                node: 9999
+              },
+              include: envIncludes
+            },
+            jsc: {
+              parser: {
+                syntax: "typescript",
+                tsx: true
+              },
+              transform: {
+                react: {
+                  runtime: "preserve"
+                }
+              },
+              externalHelpers: false,
+              assumptions: {
+                setPublicClassFields: true,
+                privateFieldsAsProperties: true
+              }
+            },
+            isModule: !id.endsWith(".cjs")
+          })).code
+        };
+      } catch (err) {}
+    }
+  };
+}
+function getHmrRuntimeSource() {
+  return `
+// vxrn HMR runtime for rolldown devMode
+var BaseDevRuntime = DevRuntime;
+
+class ReactNativeDevRuntime extends BaseDevRuntime {
+  constructor() {
+    var clientId = 'rn-' + Date.now() + '-' + Math.random().toString(36).slice(2);
+    super(clientId);
+    this._socket = null;
+    this.moduleHotContexts = {};
+    this.lastSeq = 0;
+  }
+
+  createModuleHotContext(moduleId) {
+    var runtime = this;
+    var ctx = {
+      acceptCallbacks: [],
+      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() { runtime.requestReload('module invalidated: ' + moduleId); },
+      on: function() {},
+      off: function() {},
+      send: function() {},
+      get refresh() { return globalThis.__ReactRefresh; },
+      get refreshUtils() {
+        return {
+          isReactRefreshBoundary: function(exports) {
+            if (!globalThis.__ReactRefresh) return false;
+            if (globalThis.__ReactRefresh.isLikelyComponentType(exports)) return true;
+            if (!exports || typeof exports !== 'object') return false;
+            var hasExports = false, allComponents = true;
+            for (var key in exports) {
+              hasExports = true;
+              if (key === '__esModule') continue;
+              if (!globalThis.__ReactRefresh.isLikelyComponentType(exports[key])) allComponents = false;
+            }
+            return hasExports && allComponents;
+          },
+          enqueueUpdate: function() {
+            if (globalThis.__ReactRefresh) {
+              setTimeout(function() { globalThis.__ReactRefresh.performReactRefresh(); }, 50);
+            }
+          }
+        };
+      }
+    };
+    this.moduleHotContexts[moduleId] = ctx;
+    return ctx;
+  }
+
+  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]);
+      }
+    }
+
+    for (var p = 0; p < changedIds.length; p++) {
+      try {
+        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;
+  }
+
+  requestReload(reason) {
+    if (this._socket && this._socket.readyState === 1) {
+      this._socket.send(JSON.stringify({ type: 'hmr:invalidate', reason: reason }));
+    }
+  }
+
+  setup(socket) {
+    if (this._socket) return;
+    this._socket = socket;
+  }
+}
+
+globalThis.__rolldown_runtime__ = new ReactNativeDevRuntime();
+`;
+}
+export { buildNativeBundle, createNativeDevEngine, getHermesSWCIncludes, getHmrRuntimeSource, getNativeTransformConfig, hmrClientNoopPlugin, vxrnCompilerPlugin, wrapNativeBundleModuleScope };
+//# sourceMappingURL=createNativeDevEngine.mjs.map