vxrn 1.12.8 → 1.13.0

package/dist/utils/createNativeDevEngine.native.js

@@ -0,0 +1,702 @@
+import { writeFileSync } from "fs";
+import { basename, dirname, extname, join, relative } from "path";
+import { DEFAULT_ASSET_EXTS } from "../constants/defaults.native.js";
+import { getNativePrelude } from "../runtime/native-prelude.native.js";
+function _instanceof(left, right) {
+  return right != null && typeof Symbol < "u" && right[Symbol.hasInstance] ? !!right[Symbol.hasInstance](left) : left instanceof right;
+}
+var FLOW_FILE_PATTERN = /node_modules[\\/](?:react-native|@react-native)[\\/].*\.js$/;
+function getResolveExtensions(platform) {
+  var platformExts = platform === "ios" ? [".ios.tsx", ".ios.ts", ".ios.jsx", ".ios.js"] : [".android.tsx", ".android.ts", ".android.jsx", ".android.js"],
+    nativeExts = [".native.tsx", ".native.ts", ".native.jsx", ".native.js"],
+    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(dev) {
+  return {
+    jsx: {
+      // use 'classic' mode (babel plugin-transform-react-jsx)
+      // 'automatic' has files where jsxDEV import fails to resolve
+      runtime: "classic"
+    },
+    define: {
+      "process.env.NODE_ENV": dev ? '"development"' : '"production"',
+      "process.env.VXRN_REACT_19": "false",
+      __DEV__: dev ? "true" : "false"
+    },
+    // auto-inject React import for classic JSX (React.createElement)
+    inject: {
+      React: "react"
+    }
+  };
+}
+function getNativePlugins(root, platform, viteImportGlobPlugin, dev) {
+  return [
+  // stub CSS imports — native doesn't support CSS and rolldown removed CSS bundling
+  cssStubPlugin(),
+  // handle import.meta.glob (used by One's route system)
+  viteImportGlobPlugin({
+    root
+  }),
+  // strip Flow types from react-native and @react-native packages
+  flowStripPlugin(),
+  // handle asset imports (.png, .jpg, .ttf, etc.)
+  assetPlugin({
+    root,
+    platform
+  }),
+  // @vxrn/compiler babel transforms: reanimated worklets, async generators,
+  // react-native codegen, react compiler — same pipeline as metro
+  vxrnCompilerPlugin(platform, dev),
+  // hermes compat: transform class properties and private fields
+  hermesCompatSWCPlugin(dev),
+  // downgrade polyfill "not configurable" errors to warnings (hermes v1)
+  polyfillErrorDowngradePlugin(),
+  // strip DevSettings in prod (dev-only native module)
+  stripDevSettingsPlugin(dev)];
+}
+function getNativeOutputOptions(prelude) {
+  return {
+    format: "esm",
+    sourcemap: !0,
+    intro: prelude,
+    codeSplitting: !1,
+    strictExecutionOrder: !0
+  };
+}
+function postProcessNativeBundle(code) {
+  return code = code.replace(/^\s*export\s*\{[^}]*\}\s*;?\s*$/gm, ""), code = code.replace(/^if \(import\.meta\.hot\).*$/gm, ""), code;
+}
+async function downlevelClassFieldsInBundle(code) {
+  var startMarker = "//#region \\0rolldown/runtime.js",
+    endMarker = "//#endregion",
+    startIdx = code.indexOf(startMarker);
+  if (startIdx === -1) return code;
+  var endIdx = code.indexOf(endMarker, startIdx);
+  if (endIdx === -1) return code;
+  var runtimeEnd = endIdx + endMarker.length,
+    runtimeSection = code.slice(startIdx, runtimeEnd);
+  try {
+    var swc = await import("@swc/core"),
+      result = await swc.transform(runtimeSection, {
+        filename: "rolldown-runtime.js",
+        configFile: !1,
+        swcrc: !1,
+        sourceMaps: !1,
+        inputSourceMap: !1,
+        isModule: !1,
+        env: {
+          targets: {
+            node: 9999
+          },
+          include: ["transform-class-properties", "transform-class-static-block", "transform-private-methods", "transform-private-property-in-object"]
+        },
+        jsc: {
+          parser: {
+            syntax: "ecmascript"
+          },
+          transform: {
+            react: {
+              runtime: "preserve"
+            }
+          },
+          externalHelpers: !1,
+          assumptions: {
+            setPublicClassFields: !0,
+            privateFieldsAsProperties: !0
+          }
+        }
+      });
+    return code.slice(0, startIdx) + result.code + code.slice(runtimeEnd);
+  } catch (err) {
+    return console.warn("[vxrn] downlevelClassFieldsInBundle failed, returning original:", err), code;
+  }
+}
+async function createNativeDevEngine(options) {
+  var {
+      root,
+      port,
+      host = "localhost",
+      platform,
+      serverUrl,
+      plugins: userPlugins = [],
+      onHmrUpdate
+    } = options,
+    {
+      dev,
+      viteImportGlobPlugin
+    } = await import("rolldown/experimental"),
+    hmrRuntimeSource = getHmrRuntimeSource(),
+    prelude = getNativePrelude({
+      dev: !0,
+      platform,
+      serverUrl: serverUrl || `http://${host}:${port}`
+    }),
+    entryFile = generateNativeEntry(root),
+    currentBundle = null,
+    bundleResolve = null,
+    bundlePromise = null,
+    resolvedHost = host === "0.0.0.0" ? "localhost" : host,
+    inputOptions = {
+      input: entryFile,
+      cwd: root,
+      platform: "neutral",
+      resolve: getNativeResolveConfig(platform),
+      transform: getNativeTransformConfig(!0),
+      experimental: {
+        devMode: {
+          implement: hmrRuntimeSource,
+          host,
+          port
+        },
+        incrementalBuild: !0
+      },
+      treeshake: !1,
+      // some react-native ecosystem packages import symbols that don't exist in
+      // the declared entry (e.g. @react-navigation/elements imports NavigationProvider
+      // from @react-navigation/native which doesn't export it). metro silently shims
+      // these — rolldown needs an explicit opt-in.
+      shimMissingExports: !0,
+      moduleTypes: {
+        ".js": "jsx"
+      },
+      plugins: [...getNativePlugins(root, platform, viteImportGlobPlugin, !0),
+      // add import.meta.hot.accept() to user files for HMR boundaries
+      // rolldown compiles import.meta.hot -> createModuleHotContext at build time
+      nativeReactRefreshPlugin(), ...userPlugins]
+    },
+    outputOptions = {
+      ...getNativeOutputOptions(prelude),
+      // connect HMR WebSocket using RN's WebSocket module (not the global)
+      outro: `
+try {
+  var __WS = (init_WebSocket(), __toCommonJS(WebSocket_exports)).default;
+  var __hmrUrl = 'ws://${resolvedHost}:${port}/hot';
+  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);
+      } 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, __hmrUrl.replace('ws://', 'http://'));
+    }
+  };
+  __hmrWS.onerror = function(e) { console.warn('[vxrn] HMR connection error:', e.message || e); };
+} catch(e) {}
+`
+    },
+    engine = await dev(inputOptions, outputOptions, {
+      onOutput: async function (result) {
+        if (_instanceof(result, Error)) {
+          console.error("[vxrn] native bundle error:", result.message);
+          return;
+        }
+        var output = result,
+          chunk = output.output.find(function (o) {
+            return o.type === "chunk" && o.isEntry;
+          });
+        if (chunk && "code" in chunk) {
+          var _chunk_map,
+            code = postProcessNativeBundle(chunk.code);
+          code = await downlevelClassFieldsInBundle(code);
+          var hmrClientStub = 'registerCallableModule("HMRClient",{setup:function(){},enable:function(){},disable:function(){},registerBundle:function(){},log:function(){}})';
+          code = code.replace(/registerCallableModule\s*\(\s*["']AppRegistry["']/, function (match) {
+            return hmrClientStub + "," + match;
+          }), currentBundle = {
+            code,
+            map: (_chunk_map = chunk.map) === null || _chunk_map === void 0 ? void 0 : _chunk_map.toString()
+          }, console.info(`[vxrn] native bundle ready (${Math.round(chunk.code.length / 1024)}KB)`), bundleResolve && (bundleResolve(currentBundle), bundleResolve = null, bundlePromise = null);
+        }
+      },
+      onHmrUpdates: async function (result) {
+        if (_instanceof(result, Error)) {
+          console.error("[vxrn] HMR error:", result.message), onHmrUpdate?.({
+            type: "hmr:error"
+          });
+          return;
+        }
+        var updates = result.updates || [],
+          _iteratorNormalCompletion = !0,
+          _didIteratorError = !1,
+          _iteratorError = void 0;
+        try {
+          for (var _iterator = updates[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+            var item = _step.value,
+              update = item.update || item;
+            update.type === "Patch" && update.code ? onHmrUpdate?.({
+              type: "hmr:update",
+              code: update.code
+            }) : update.type === "FullReload" && onHmrUpdate?.({
+              type: "hmr:reload"
+            });
+          }
+        } catch (err) {
+          _didIteratorError = !0, _iteratorError = err;
+        } finally {
+          try {
+            !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+          } finally {
+            if (_didIteratorError) throw _iteratorError;
+          }
+        }
+        updates.length === 0 && onHmrUpdate?.({
+          type: "hmr:reload"
+        });
+      },
+      rebuildStrategy: "auto",
+      watch: {}
+    });
+  return await engine.run(), {
+    engine,
+    async getBundle() {
+      if (currentBundle) return currentBundle;
+      if (!bundlePromise) {
+        var timeoutId;
+        bundlePromise = new Promise(function (resolve, reject) {
+          bundleResolve = function (value) {
+            clearTimeout(timeoutId), resolve(value);
+          }, timeoutId = setTimeout(function () {
+            return reject(new Error("[vxrn] bundle build timed out after 120s"));
+          }, 12e4);
+        });
+      }
+      return await engine.ensureLatestBuildOutput(), currentBundle || bundlePromise;
+    },
+    async close() {
+      await engine.close();
+    }
+  };
+}
+async function buildNativeBundle(options) {
+  var _chunk_map,
+    {
+      root,
+      platform,
+      dev = !1,
+      serverUrl,
+      plugins: userPlugins = []
+    } = options,
+    {
+      build
+    } = await import("rolldown"),
+    {
+      viteImportGlobPlugin
+    } = await import("rolldown/experimental"),
+    prelude = getNativePrelude({
+      dev,
+      platform,
+      serverUrl
+    }),
+    entryFile = generateNativeEntry(root, {
+      dev
+    }),
+    result = await build({
+      input: entryFile,
+      cwd: root,
+      platform: "neutral",
+      resolve: getNativeResolveConfig(platform),
+      transform: getNativeTransformConfig(dev),
+      treeshake: !dev,
+      shimMissingExports: !0,
+      moduleTypes: {
+        ".js": "jsx"
+      },
+      plugins: [...getNativePlugins(root, platform, viteImportGlobPlugin, dev), ...userPlugins],
+      output: getNativeOutputOptions(prelude)
+    }),
+    chunk = result.output.find(function (o) {
+      return o.type === "chunk" && o.isEntry;
+    });
+  if (!chunk || !("code" in chunk)) throw new Error("[vxrn] production build produced no output");
+  var code = postProcessNativeBundle(chunk.code);
+  return code = await downlevelClassFieldsInBundle(code), {
+    code,
+    map: (_chunk_map = chunk.map) === null || _chunk_map === void 0 ? void 0 : _chunk_map.toString()
+  };
+}
+function generateNativeEntry(root, opts) {
+  var isDev = opts?.dev !== !1,
+    entryPath = join(root, ".vxrn-entry-native.tsx"),
+    refreshSetup = 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;
+` : "",
+    entryCode = `
+// auto-generated native entry for rolldown
+${refreshSetup}
+import { createApp } from 'one';
+
+var _routes = import.meta.glob(['./app/**/*.tsx', './app/**/*.ts', '!./app/**/*+api.*', '!./app/**/*.test.*', '!./app/**/*.d.ts'], { exhaustive: true });
+// fix route keys: One expects '/app/...' prefix but import.meta.glob returns './app/...'
+var routes = {};
+Object.keys(_routes).forEach(function(key) {
+  routes[key.replace(/^\\./, '')] = _routes[key];
+});
+
+createApp({
+  routes: routes,
+  routerRoot: 'app',
+  flags: {},
+});
+`;
+  return writeFileSync(entryPath, entryCode), entryPath;
+}
+function cssStubPlugin() {
+  return {
+    name: "vxrn:css-stub",
+    load: {
+      handler(id) {
+        if (/\.css$/.test(id)) return {
+          code: "",
+          moduleType: "js"
+        };
+      }
+    }
+  };
+}
+function vxrnCompilerPlugin(platform, dev) {
+  var compiler = null;
+  return {
+    name: "vxrn:compiler",
+    async transform(code, id) {
+      if (/\.[cm]?[jt]sx?$/.test(id) && !(id.includes("\0") || id.includes("virtual:"))) try {
+        compiler || (compiler = await import("@vxrn/compiler"));
+        var props = {
+            id,
+            code,
+            development: dev,
+            environment: platform,
+            reactForRNVersion: "19"
+          },
+          babelOptions = compiler.getBabelOptions(props);
+        if (!babelOptions) return;
+        var result = await compiler.transformBabel(id, code, babelOptions);
+        if (result?.code) return {
+          code: result.code
+        };
+      } catch (err) {
+        dev && console.warn(`[vxrn:compiler] ${id}: ${err.message || err}`);
+      }
+    }
+  };
+}
+function flowStripPlugin() {
+  return {
+    name: "vxrn:flow-strip",
+    transform: {
+      async handler(code, id) {
+        if (FLOW_FILE_PATTERN.test(id)) try {
+          var fft = await import("fast-flow-transform"),
+            result = await fft.default({
+              filename: id,
+              source: code,
+              sourcemap: !0,
+              dialect: "flow",
+              format: "pretty"
+            });
+          return {
+            code: result.code,
+            map: result.map
+          };
+        } catch (err) {
+          console.warn(`[vxrn:flow-strip] ${id}: ${err.message}`);
+        }
+      }
+    }
+  };
+}
+function assetPlugin(opts) {
+  var assetRegex = new RegExp(`\\.(?:${DEFAULT_ASSET_EXTS.join("|")})$`);
+  return {
+    name: "vxrn:asset",
+    load: {
+      async handler(id) {
+        if (assetRegex.test(id)) {
+          var ext = extname(id).slice(1),
+            name = basename(id, `.${ext}`),
+            dir = dirname(id),
+            relativePath = relative(opts.root, id),
+            httpLocation = "/assets/" + dirname(relativePath),
+            assetData = {
+              __packager_asset: !0,
+              name,
+              type: ext,
+              scales: [1],
+              httpServerLocation: httpLocation,
+              fileSystemLocation: dir,
+              hash: "",
+              width: void 0,
+              height: void 0
+            };
+          if (["png", "jpg", "jpeg", "gif", "webp", "bmp"].includes(ext)) try {
+            var {
+                imageSize
+              } = await import("image-size"),
+              dims = imageSize(id);
+            assetData.width = dims.width, assetData.height = dims.height;
+          } catch {}
+          var code = `module.exports = require('react-native/Libraries/Image/AssetRegistry').registerAsset(${JSON.stringify(assetData)});`;
+          return {
+            code,
+            moduleType: "js"
+          };
+        }
+      }
+    }
+  };
+}
+function hermesCompatSWCPlugin(dev) {
+  var swc = null;
+  return {
+    name: "vxrn:hermes-compat",
+    async transform(code, id) {
+      if (/\.[cm]?[jt]sx?$/.test(id) && !(id.includes("\0") || id.includes("virtual:"))) {
+        var hasClass = code.includes("class ") || code.includes("class{"),
+          hasAsync = !dev && code.includes("async ");
+        if (!(!hasClass && !hasAsync) && !(code.length > 5e5)) try {
+          swc || (swc = await import("@swc/core"));
+          var envIncludes = ["transform-class-properties", "transform-class-static-block", "transform-private-methods", "transform-private-property-in-object", ...(dev ? [] : ["transform-classes", "transform-async-to-generator"])],
+            result = await swc.transform(code, {
+              filename: id,
+              configFile: !1,
+              swcrc: !1,
+              sourceMaps: !1,
+              inputSourceMap: !1,
+              env: {
+                targets: {
+                  node: 9999
+                },
+                include: envIncludes
+              },
+              jsc: {
+                parser: {
+                  syntax: "typescript",
+                  tsx: !0
+                },
+                transform: {
+                  react: {
+                    runtime: "preserve"
+                  }
+                },
+                externalHelpers: !1,
+                assumptions: {
+                  setPublicClassFields: !0,
+                  privateFieldsAsProperties: !0
+                }
+              },
+              isModule: !id.endsWith(".cjs")
+            });
+          return {
+            code: result.code
+          };
+        } catch {}
+      }
+    }
+  };
+}
+function polyfillErrorDowngradePlugin() {
+  return {
+    name: "vxrn:polyfill-error-downgrade",
+    transform(code, id) {
+      if (id.includes("node_modules") && code.includes('console.error("Failed to set polyfill.')) return {
+        code: code.replace(/console\.error\(\s*"Failed to set polyfill\.\s*"\s*\+/g, 'console.warn("Failed to set polyfill. " +')
+      };
+    }
+  };
+}
+function stripDevSettingsPlugin(dev) {
+  return {
+    name: "vxrn:strip-dev-settings",
+    transform(code, id) {
+      if (!dev && code.includes("DevSettings")) return {
+        code: code.replace(/getEnforcing\s*\(\s*["']DevSettings["']\s*\)/g, "patched_getEnforcing_DevSettings_will_not_work_in_production()")
+      };
+    }
+  };
+}
+function nativeReactRefreshPlugin() {
+  return {
+    name: "vxrn:react-refresh",
+    async transform(code, id) {
+      if (!id.includes("node_modules") && !id.includes(".vxrn-entry-native") && !id.startsWith("\0") && /\.[tj]sx?$/.test(id) && /[<]|function\s|=>\s*[{(]/.test(code)) try {
+        var babel = await import("@babel/core"),
+          parserPlugins = [];
+        id.endsWith(".tsx") ? parserPlugins.push(["@babel/plugin-syntax-typescript", {
+          isTSX: !0
+        }]) : id.endsWith(".ts") ? parserPlugins.push("@babel/plugin-syntax-typescript") : id.endsWith(".jsx") && parserPlugins.push("@babel/plugin-syntax-jsx");
+        var result = await babel.transformAsync(code, {
+          filename: id,
+          babelrc: !1,
+          configFile: !1,
+          compact: !1,
+          plugins: [...parserPlugins, "react-refresh/babel"],
+          sourceType: "unambiguous"
+        });
+        if (result?.code) {
+          var escapedId = id.replace(/\\/g, "\\\\").replace(/"/g, '\\"'),
+            wrappedCode = `
+var __prevRefreshReg = globalThis.$RefreshReg$;
+var __prevRefreshSig = globalThis.$RefreshSig$;
+if (globalThis.__ReactRefresh) {
+  globalThis.$RefreshReg$ = function(type, id) {
+    globalThis.__ReactRefresh.register(type, "${escapedId}" + " " + id);
+  };
+  globalThis.$RefreshSig$ = globalThis.__ReactRefresh.createSignatureFunctionForTransform;
+}
+
+${result.code}
+
+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: wrappedCode
+          };
+        }
+      } catch {
+        return {
+          code: code + `
+if (import.meta.hot) { import.meta.hot.accept(); }
+`
+        };
+      }
+    }
+  };
+}
+function getHmrRuntimeSource() {
+  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;
+    this._socket = null;
+    this._queue = [];
+    this.moduleHotContexts = {};
+  }
+
+  createModuleHotContext(moduleId) {
+    var ctx = {
+      acceptCallbacks: [],
+      accept: function(cb) {
+        if (cb) ctx.acceptCallbacks.push({ deps: [moduleId], fn: cb });
+      },
+      invalidate: function() {},
+      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;
+  }
+
+  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);
+        }
+      }
+    }
+  }
+
+  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 });
+    }
+
+    // HMR message handling is done by the outro WebSocket handler
+    // the runtime's setup() only needs to flush queued messages
+  }
+}
+
+globalThis.__rolldown_runtime__ = new ReactNativeDevRuntime();
+`;
+}
+export { buildNativeBundle, createNativeDevEngine };
+//# sourceMappingURL=createNativeDevEngine.native.js.map