rnxsim 0.1.344 → 0.1.346

package/dist-lib/metro.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.344 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.346 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __create = Object.create;
@@ -39,8 +39,421 @@ __export(metro_plugin_exports, {
 module.exports = __toCommonJS(metro_plugin_exports);
 var import_fs2 = __toESM(require("fs"), 1);
 var import_module = require("module");
+var import_node_crypto2 = require("node:crypto");
 var import_path2 = __toESM(require("path"), 1);
 
+// src/dev-server-open.ts
+var import_node_child_process = require("node:child_process");
+var import_node_crypto = require("node:crypto");
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_http = __toESM(require("node:http"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
+var scheduledMetroOpens = /* @__PURE__ */ new Set();
+function resolveRnxDesktopAppName(open, projectRoot) {
+  if (!open) return null;
+  if (typeof open === "object") {
+    const appName = open.appName.trim();
+    if (!appName) throw new Error("rnx: open.appName must not be empty");
+    return appName;
+  }
+  const packageJsonPath = import_node_path.default.join(projectRoot, "package.json");
+  const packageJson = JSON.parse(import_node_fs.default.readFileSync(packageJsonPath, "utf8"));
+  const packageName = packageJson && typeof packageJson === "object" ? Reflect.get(packageJson, "name") : void 0;
+  if (typeof packageName !== "string" || !packageName.trim()) {
+    throw new Error(`rnx: ${packageJsonPath} must declare a package name`);
+  }
+  return packageName.trim();
+}
+function tagRnxBundleForPlugin(bundleUrl, replacementOrigin, replacementToken, projectRoot, appName) {
+  const absolute = /^[a-z][a-z\d+.-]*:\/\//i.test(bundleUrl);
+  const url = new URL(bundleUrl, absolute ? void 0 : "http://rnx.local");
+  if (appName) {
+    url.searchParams.set("rnxAppName", appName);
+    url.searchParams.set(
+      "rnxProjectId",
+      (0, import_node_crypto.createHash)("sha256").update(import_node_fs.default.realpathSync(projectRoot)).digest("hex").slice(0, 32)
+    );
+  }
+  url.searchParams.set("rnxReplacementOrigin", replacementOrigin);
+  url.searchParams.set("rnxReplacementToken", replacementToken);
+  return absolute ? url.toString() : `${url.pathname}${url.search}${url.hash}`;
+}
+function resolveRnxDesktopLaunchTarget(port, bundleUrl) {
+  return new URL(bundleUrl, `http://localhost:${port}`).toString();
+}
+function buildRnxDesktopOpenArgs(bundleUrl) {
+  return ["open", bundleUrl, "--new", "--driver", "electron", "--no-describe"];
+}
+function observeRnxDesktopLaunch(child, appName) {
+  let stderr = "";
+  let spawnFailed = false;
+  child.stderr?.setEncoding("utf8");
+  child.stderr?.on("data", (chunk) => {
+    stderr = `${stderr}${chunk}`.slice(-16384);
+  });
+  child.once("error", (error) => {
+    spawnFailed = true;
+    console.error(`[rnx] could not open ${appName}: ${error.message}`);
+  });
+  child.once("close", (code, signal) => {
+    if (spawnFailed) return;
+    if (code === 0) {
+      console.log(`[rnx] opened ${appName} in the desktop simulator`);
+      return;
+    }
+    const detail = stderr.trim() || (signal ? `signal ${signal}` : `exit ${code}`);
+    console.error(`[rnx] could not open ${appName}: ${detail}`);
+  });
+}
+function launchRnxDesktop(bundleUrl, appName) {
+  const packageRoot = import_node_path.default.resolve(import_node_path.default.dirname((0, import_node_url.fileURLToPath)(__sootsim_import_meta_url)), "..");
+  const binPath = import_node_path.default.join(packageRoot, "dist-cli", "bin.js");
+  console.log(`[rnx] opening ${appName} in the desktop simulator`);
+  const child = (0, import_node_child_process.spawn)(
+    process.execPath,
+    [binPath, ...buildRnxDesktopOpenArgs(bundleUrl)],
+    {
+      stdio: ["ignore", "ignore", "pipe"],
+      windowsHide: true
+    }
+  );
+  observeRnxDesktopLaunch(child, appName);
+}
+function openRnxDesktopWhenMetroIsReady({
+  port,
+  bundleUrl,
+  appName,
+  projectRoot,
+  serverId,
+  intervalMs = 100,
+  timeoutMs = 3e4,
+  launch = launchRnxDesktop
+}) {
+  const key = `${projectRoot}\0${port}`;
+  if (scheduledMetroOpens.has(key)) return Promise.resolve(false);
+  scheduledMetroOpens.add(key);
+  const deadline = Date.now() + timeoutMs;
+  return new Promise((resolve) => {
+    let finished = false;
+    const finish = (opened) => {
+      if (finished) return;
+      finished = true;
+      scheduledMetroOpens.delete(key);
+      resolve(opened);
+    };
+    const retry = () => {
+      if (finished) return;
+      if (Date.now() >= deadline) {
+        console.error(
+          `[rnx] could not open ${appName}: Metro did not become ready on port ${port}`
+        );
+        finish(false);
+        return;
+      }
+      const timer = setTimeout(check, intervalMs);
+      timer.unref();
+    };
+    const check = () => {
+      const request = import_node_http.default.get(
+        `http://127.0.0.1:${port}/__server-scan`,
+        { headers: { Accept: "application/json" } },
+        (response) => {
+          let body = "";
+          response.setEncoding("utf8");
+          response.on("data", (chunk) => {
+            body = `${body}${chunk}`.slice(0, 65536);
+          });
+          response.once("end", () => {
+            try {
+              const scan = JSON.parse(body);
+              const matches = response.statusCode === 200 && Array.isArray(scan) && scan.some((entry) => {
+                if (!entry || typeof entry !== "object") return false;
+                const scannedPort = Reflect.get(entry, "port");
+                const projectName = Reflect.get(entry, "projectName");
+                const scannedServerId = Reflect.get(entry, "rnxServerId");
+                const scannedBundle = Reflect.get(entry, "bundleUrl");
+                if (scannedPort !== port || projectName !== appName || scannedServerId !== serverId || typeof scannedBundle !== "string") {
+                  return false;
+                }
+                return new URL(scannedBundle).searchParams.get("rnxAppName") === appName;
+              });
+              if (matches) {
+                launch(bundleUrl, appName);
+                finish(true);
+                return;
+              }
+            } catch {
+            }
+            retry();
+          });
+        }
+      );
+      request.setTimeout(Math.min(1e3, timeoutMs), () => request.destroy());
+      request.once("error", retry);
+    };
+    check();
+  });
+}
+
+// src/host/replacement-module-handler.ts
+var import_promises = __toESM(require("node:fs/promises"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
+var import_esbuild = require("esbuild");
+
+// src/backend-origin.ts
+function normalizeHostname(hostname) {
+  return hostname.replace(/^\[|\]$/g, "").toLowerCase();
+}
+function isLoopbackHost(hostname) {
+  const normalized = normalizeHostname(hostname);
+  return normalized === "localhost" || normalized.endsWith(".localhost") || normalized === "0.0.0.0" || normalized === "::1" || /^127(?:\.\d{1,3}){3}$/.test(normalized);
+}
+
+// src/host/replacement-module-handler.ts
+var REPLACEMENT_MODULE_ROUTE = "/__sootsim-replacement-module";
+var REPLACEMENT_RUNTIME_PREFIX = "/__sootsim-replacement-runtime";
+function getReplacementLoader(filePath) {
+  const ext = import_node_path2.default.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".js":
+      return "js";
+    case ".jsx":
+      return "jsx";
+    case ".ts":
+      return "ts";
+    case ".tsx":
+      return "tsx";
+    default:
+      return null;
+  }
+}
+function reactRuntimeSource(reactBridgeUrl) {
+  if (reactBridgeUrl) {
+    return `export * from ${JSON.stringify(reactBridgeUrl)};
+import React from ${JSON.stringify(reactBridgeUrl)};
+export default React;
+`;
+  }
+  return `const bridge = globalThis.__sootsim_react_bridge
+if (!bridge) throw new Error('[rnx] replacement React bridge is not ready')
+export default bridge.default
+export const Activity = bridge.Activity
+export const Children = bridge.Children
+export const Component = bridge.Component
+export const Fragment = bridge.Fragment
+export const Profiler = bridge.Profiler
+export const PureComponent = bridge.PureComponent
+export const StrictMode = bridge.StrictMode
+export const Suspense = bridge.Suspense
+export const __CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = bridge.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE
+export const __COMPILER_RUNTIME = bridge.__COMPILER_RUNTIME
+export const __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = bridge.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
+export const act = bridge.act
+export const cache = bridge.cache
+export const cacheSignal = bridge.cacheSignal
+export const captureOwnerStack = bridge.captureOwnerStack
+export const cloneElement = bridge.cloneElement
+export const createContext = bridge.createContext
+export const createElement = bridge.createElement
+export const createRef = bridge.createRef
+export const forwardRef = bridge.forwardRef
+export const isValidElement = bridge.isValidElement
+export const lazy = bridge.lazy
+export const memo = bridge.memo
+export const startTransition = bridge.startTransition
+export const unstable_useCacheRefresh = bridge.unstable_useCacheRefresh
+export const use = bridge.use
+export const useActionState = bridge.useActionState
+export const useCallback = bridge.useCallback
+export const useContext = bridge.useContext
+export const useDebugValue = bridge.useDebugValue
+export const useDeferredValue = bridge.useDeferredValue
+export const useEffect = bridge.useEffect
+export const useEffectEvent = bridge.useEffectEvent
+export const useId = bridge.useId
+export const useImperativeHandle = bridge.useImperativeHandle
+export const useInsertionEffect = bridge.useInsertionEffect
+export const useLayoutEffect = bridge.useLayoutEffect
+export const useMemo = bridge.useMemo
+export const useOptimistic = bridge.useOptimistic
+export const useReducer = bridge.useReducer
+export const useRef = bridge.useRef
+export const useState = bridge.useState
+export const useSyncExternalStore = bridge.useSyncExternalStore
+export const useTransition = bridge.useTransition
+export const version = bridge.version
+`;
+}
+function reactNativeRuntimeSource() {
+  return `const rn = globalThis.__sootsim_components__ || {}
+export default rn
+export const View = rn.View
+export const Text = rn.Text
+export const Image = rn.Image
+export const ScrollView = rn.ScrollView
+export const FlatList = rn.FlatList
+export const Pressable = rn.Pressable
+export const TouchableOpacity = rn.TouchableOpacity
+export const TouchableWithoutFeedback = rn.TouchableWithoutFeedback
+export const TouchableHighlight = rn.TouchableHighlight
+export const TextInput = rn.TextInput
+export const ActivityIndicator = rn.ActivityIndicator
+export const KeyboardAvoidingView = rn.KeyboardAvoidingView
+export const Button = rn.Button
+export const Modal = rn.Modal
+export const Switch = rn.Switch
+export const StyleSheet = rn.StyleSheet
+export const Platform = rn.Platform
+export const Keyboard = rn.Keyboard
+export const Dimensions = rn.Dimensions
+export const Appearance = rn.Appearance
+`;
+}
+function sendJavaScript(req, res, source) {
+  const origin = req.headers.origin;
+  let allowedOrigin;
+  if (origin) {
+    try {
+      if (isLoopbackHost(new URL(origin).hostname)) allowedOrigin = origin;
+    } catch {
+    }
+  }
+  res.writeHead(200, {
+    "Content-Type": "application/javascript; charset=utf-8",
+    "Cache-Control": "no-cache",
+    ...allowedOrigin ? { "Access-Control-Allow-Origin": allowedOrigin, Vary: "Origin" } : {}
+  });
+  res.end(req.method === "HEAD" ? void 0 : source);
+}
+function isReplacementModuleRequestUrl(rawUrl) {
+  if (!rawUrl) return false;
+  try {
+    const pathname = new URL(rawUrl, "http://rnx.local").pathname;
+    return pathname === REPLACEMENT_MODULE_ROUTE || pathname.startsWith(`${REPLACEMENT_RUNTIME_PREFIX}/`);
+  } catch {
+    return false;
+  }
+}
+async function handleReplacementModuleRequest(req, res, options = {}) {
+  const rawUrl = req.url || "";
+  let url;
+  try {
+    url = new URL(rawUrl, "http://rnx.local");
+  } catch {
+    return false;
+  }
+  if (options.requireLoopbackOrigin) {
+    const origin = req.headers.origin;
+    const remoteAddress = req.socket.remoteAddress?.replace(/^::ffff:/, "");
+    let allowed = Boolean(remoteAddress && isLoopbackHost(remoteAddress));
+    if (allowed && origin) {
+      try {
+        allowed = isLoopbackHost(new URL(origin).hostname);
+      } catch {
+        allowed = false;
+      }
+    }
+    if (!allowed) {
+      res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("replacement modules are available only to loopback origins");
+      return true;
+    }
+  }
+  if (url.pathname === `${REPLACEMENT_RUNTIME_PREFIX}/react`) {
+    sendJavaScript(req, res, reactRuntimeSource(options.reactBridgeUrl));
+    return true;
+  }
+  if (url.pathname === `${REPLACEMENT_RUNTIME_PREFIX}/react-native`) {
+    sendJavaScript(req, res, reactNativeRuntimeSource());
+    return true;
+  }
+  if (url.pathname !== REPLACEMENT_MODULE_ROUTE) return false;
+  if (options.requestToken && url.searchParams.get("token") !== options.requestToken) {
+    res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end("replacement module request token is invalid");
+    return true;
+  }
+  const targetPath = url.searchParams.get("path");
+  if (!targetPath) {
+    res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end("missing path param");
+    return true;
+  }
+  const loader = getReplacementLoader(targetPath);
+  if (!loader) {
+    res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end("replacement files must be .js, .jsx, .ts, or .tsx");
+    return true;
+  }
+  if (!import_node_path2.default.isAbsolute(targetPath)) {
+    res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end("replacement file path must be absolute");
+    return true;
+  }
+  let resolvedProjectRoot;
+  if (options.projectRoot) {
+    const lexicalProjectRoot = import_node_path2.default.resolve(options.projectRoot);
+    resolvedProjectRoot = await import_promises.default.realpath(options.projectRoot);
+    const lexicalTarget = import_node_path2.default.relative(lexicalProjectRoot, targetPath);
+    if (lexicalTarget.startsWith("..") || import_node_path2.default.isAbsolute(lexicalTarget)) {
+      res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("replacement file must be inside the project root");
+      return true;
+    }
+  }
+  let resolvedTargetPath;
+  try {
+    resolvedTargetPath = await import_promises.default.realpath(targetPath);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end(`replacement file not found: ${message}`);
+    return true;
+  }
+  if (resolvedProjectRoot) {
+    const relativeTarget = import_node_path2.default.relative(resolvedProjectRoot, resolvedTargetPath);
+    if (relativeTarget.startsWith("..") || import_node_path2.default.isAbsolute(relativeTarget)) {
+      res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("replacement file must be inside the project root");
+      return true;
+    }
+  }
+  try {
+    const result = await (0, import_esbuild.build)({
+      entryPoints: [resolvedTargetPath],
+      bundle: true,
+      write: false,
+      format: "esm",
+      platform: "browser",
+      target: "es2022",
+      jsx: "transform",
+      jsxFactory: "React.createElement",
+      jsxFragment: "React.Fragment",
+      tsconfigRaw: { compilerOptions: { jsx: "react" } },
+      sourcemap: "inline",
+      logLevel: "silent",
+      external: ["react", "react-native"]
+    });
+    const bundledCode = result.outputFiles[0]?.text ?? "";
+    const hasReactBinding = /\bimport\s+(?:\*\s+as\s+React|React(?:\s*,|\s+from)|\{[^}]*\bdefault\s+as\s+React\b)/.test(
+      bundledCode
+    );
+    const reactImport = /\bReact\.(?:createElement|Fragment)\b/.test(bundledCode) && !hasReactBinding ? `import * as React from '${REPLACEMENT_RUNTIME_PREFIX}/react';
+` : "";
+    const runtimeCode = (reactImport + bundledCode).replace(
+      /from\s*["']react-native["']/g,
+      `from '${REPLACEMENT_RUNTIME_PREFIX}/react-native'`
+    ).replace(/from\s*["']react["']/g, `from '${REPLACEMENT_RUNTIME_PREFIX}/react'`);
+    sendJavaScript(req, res, runtimeCode);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    res.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end(`replacement bundle failed: ${message}`);
+  }
+  return true;
+}
+
 // src/metro-production-bundle.ts
 var RNXSIM_METRO_PRODUCTION_BUNDLE_OPTION = "rnxsim";
 var RNXSIM_METRO_MODULE_PATHS_PREFIX = "globalThis.__sootsimModulePaths=";
@@ -71,28 +484,28 @@ function isValidRuntimeVersion(value) {
 }
 
 // src/home-paths.ts
-var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_fs2 = __toESM(require("node:fs"), 1);
 var import_node_os = require("node:os");
-var import_node_path = __toESM(require("node:path"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
 var SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
 var ACTIVE_RUNTIME_FILE = "active";
 function sootsimHomeDir() {
   const override = process.env[SOOTSIM_HOME_ENV];
-  if (override && override.length > 0) return import_node_path.default.resolve(override);
-  return import_node_path.default.join((0, import_node_os.homedir)(), ".sootsim");
+  if (override && override.length > 0) return import_node_path3.default.resolve(override);
+  return import_node_path3.default.join((0, import_node_os.homedir)(), ".sootsim");
 }
 function runtimesDir() {
-  return import_node_path.default.join(sootsimHomeDir(), "runtimes");
+  return import_node_path3.default.join(sootsimHomeDir(), "runtimes");
 }
 function runtimeDir(version) {
-  return import_node_path.default.join(runtimesDir(), version);
+  return import_node_path3.default.join(runtimesDir(), version);
 }
 function activeRuntimeFile() {
-  return import_node_path.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
+  return import_node_path3.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
 }
 function readActiveRuntime() {
   try {
-    const value = import_node_fs.default.readFileSync(activeRuntimeFile(), "utf8").trim();
+    const value = import_node_fs2.default.readFileSync(activeRuntimeFile(), "utf8").trim();
     return value.length > 0 ? value : null;
   } catch {
     return null;
@@ -315,12 +728,22 @@ function prependRNXModulePaths(result, graph, options, projectRoot) {
   return typeof result === "string" ? result + footer : { ...result, code: result.code + footer };
 }
 function withRNX(config, options = {}) {
-  if (!options.devServer && !options.productionBundles) return config;
-  const bundleUrl = options.bundleUrl || "/index.bundle?platform=ios&dev=true&hot=true&minify=false";
+  if (!options.devServer && !options.open && !options.productionBundles) return config;
+  const cfgProjectRoot = config.projectRoot || process.cwd();
+  const appName = resolveRnxDesktopAppName(options.open, cfgProjectRoot);
+  const configuredBundleUrl = options.bundleUrl || "/index.bundle?platform=ios&dev=true&hot=true&minify=false";
   const cfgServer = config.server;
+  const port = resolveMetroPort(cfgServer);
+  const metroServerId = (0, import_node_crypto2.randomUUID)();
+  const bundleUrl = tagRnxBundleForPlugin(
+    configuredBundleUrl,
+    `http://localhost:${port}`,
+    metroServerId,
+    cfgProjectRoot,
+    appName
+  );
   const cfgResolver = config.resolver;
   const cfgSerializer = config.serializer;
-  const cfgProjectRoot = config.projectRoot || process.cwd();
   const existingEnhance = cfgServer?.enhanceMiddleware;
   const existingResolveRequest = cfgResolver?.resolveRequest;
   const existingSerializer = cfgSerializer?.customSerializer;
@@ -377,8 +800,35 @@ function withRNX(config, options = {}) {
       }
       const server = connect();
       server.use((req, res, next) => {
+        if (isReplacementModuleRequestUrl(req.url)) {
+          void handleReplacementModuleRequest(req, res, {
+            projectRoot: cfgProjectRoot,
+            requestToken: metroServerId,
+            requireLoopbackOrigin: true
+          }).then((handled) => {
+            if (!handled) next();
+          });
+          return;
+        }
         const url = req.url || "";
         const pathname = url.split("?")[0];
+        if (pathname === "/__server-scan") {
+          const absoluteBundleUrl = bundleUrl.startsWith("http") ? bundleUrl : `http://localhost:${port}${bundleUrl}`;
+          res.setHeader("content-type", "application/json");
+          res.end(
+            JSON.stringify([
+              {
+                port,
+                framework: "metro",
+                rnxServerId: metroServerId,
+                bundleUrl: absoluteBundleUrl,
+                ...appName ? { projectName: appName } : {},
+                lastSeen: Date.now()
+              }
+            ])
+          );
+          return;
+        }
         const runtimeRoot = resolveRuntimeRootForRequestHost(req.headers?.host);
         if (!runtimeRoot) {
           if (pathname === prefix || pathname === prefix + "/") {
@@ -413,7 +863,7 @@ function withRNX(config, options = {}) {
             let html = import_fs2.default.readFileSync(htmlPath, "utf8");
             html = html.replace(
               "</head>",
-              `<script>history.replaceState(null,'','${prefix}/?bundle=${encodeURIComponent(bundleUrl)}')</script></head>`
+              `<script>(function(){var u=new URL(location.href);if(!u.searchParams.has('bundle'))u.searchParams.set('bundle',${JSON.stringify(bundleUrl)});history.replaceState(null,'','${prefix}/'+u.search)})()</script></head>`
             );
             res.setHeader("content-type", "text/html");
             res.end(html);
@@ -427,12 +877,32 @@ function withRNX(config, options = {}) {
       return server;
     }
   };
+  if (appName && !process.env.CI && !process.env.SOOTSIM_NO_OPEN) {
+    void openRnxDesktopWhenMetroIsReady({
+      port,
+      bundleUrl: resolveRnxDesktopLaunchTarget(port, bundleUrl),
+      appName,
+      projectRoot: cfgProjectRoot,
+      serverId: metroServerId
+    });
+  }
   return {
     ...config,
     ...productionConfig,
-    ...options.devServer ? { server: serverConfig } : {}
+    ...options.devServer || options.open ? { server: serverConfig } : {}
   };
 }
+function resolveMetroPort(server) {
+  const inlinePort = process.argv.find((arg) => arg.startsWith("--port="))?.slice(7);
+  const portIndex = process.argv.indexOf("--port");
+  const splitPort = portIndex >= 0 ? process.argv[portIndex + 1] : void 0;
+  const rawPort = inlinePort || splitPort || process.env.RCT_METRO_PORT || server?.port || 8081;
+  const port = Number(rawPort);
+  if (!Number.isInteger(port) || port <= 0) {
+    throw new Error(`rnx: Metro port must be a positive integer, got ${rawPort}`);
+  }
+  return port;
+}
 var metro_plugin_default = withRNX;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist-lib/profiles.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.344 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.346 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __create = Object.create;

package/dist-lib/public-brand.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.344 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.346 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __defProp = Object.defineProperty;

package/dist-lib/react-native-host-modules.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.344 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.346 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __defProp = Object.defineProperty;

package/dist-lib/react-native-host-modules.mjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.344 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.346 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 
 // src/react-native-host-modules.ts
 var REACT_NATIVE_PASSTHROUGH_SPECIFIERS = [

package/dist-lib/render-mode.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.344 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.346 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __defProp = Object.defineProperty;