rnxsim 0.1.369 → 0.1.371

package/dist-lib/skills.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.369 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.371 | (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;
@@ -14659,9 +14659,9 @@ function safeChildPlistName(value) {
     name: file.toLowerCase().endsWith(".plist") ? file : `${file}.plist`
   };
 }
-async function readableSettingsBundle(path18) {
+async function readableSettingsBundle(path20) {
   try {
-    const root = await (0, import_promises.stat)((0, import_node_path.join)(path18, "Root.plist"));
+    const root = await (0, import_promises.stat)((0, import_node_path.join)(path20, "Root.plist"));
     return root.isFile() && root.size <= MAX_PLIST_BYTES;
   } catch {
     return false;
@@ -14706,11 +14706,11 @@ async function settingsBundleFingerprint(bundlePath) {
     return null;
   }
 }
-async function parsePlistRecord(path18) {
+async function parsePlistRecord(path20) {
   try {
-    const metadata = await (0, import_promises.stat)(path18);
+    const metadata = await (0, import_promises.stat)(path20);
     if (!metadata.isFile() || metadata.size > MAX_PLIST_BYTES) return null;
-    const source = await (0, import_promises.readFile)(path18, "utf8");
+    const source = await (0, import_promises.readFile)(path20, "utf8");
     const parsed = parsePlistSource(source);
     return isRecord2(parsed) ? parsed : null;
   } catch {
@@ -14972,6 +14972,25 @@ var init_optional_demo_registry = __esm({
 });
 
 // scripts/dev-server-scanner.ts
+function execGuarded(command, timeout, extra = {}) {
+  let child;
+  const ran = new Promise((resolve7, reject) => {
+    child = (0, import_child_process.exec)(command, { encoding: "utf8", timeout, ...extra }, (err, stdout) => {
+      if (err) reject(err);
+      else resolve7({ stdout });
+    });
+  });
+  const deadline = new Promise((_resolve, reject) => {
+    const timer = setTimeout(() => {
+      child?.kill("SIGKILL");
+      const err = new Error(`\`${command}\` did not exit within ${timeout}ms`);
+      Object.assign(err, { killed: true });
+      reject(err);
+    }, timeout + EXEC_EXIT_GRACE_MS);
+    timer.unref?.();
+  });
+  return Promise.race([ran, deadline]);
+}
 async function tcpPing(port, timeout = TCP_GATE_MS) {
   try {
     return await Promise.any(
@@ -14998,93 +15017,116 @@ async function tcpPing(port, timeout = TCP_GATE_MS) {
     return null;
   }
 }
-function httpGet(hostname, port, path18, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
+function httpGet(hostname, port, path20, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
   return new Promise((resolve7) => {
-    const req = import_http.default.request(
-      { hostname, port, path: path18, method, timeout, headers },
-      (res) => {
-        let body = "";
-        res.on("data", (c) => body += c.toString());
-        const contentType = (() => {
-          const raw = res.headers["content-type"];
-          if (typeof raw === "string") return raw;
-          if (Array.isArray(raw)) return raw[0];
-          return void 0;
-        })();
-        res.on(
-          "end",
-          () => resolve7({
-            statusCode: res.statusCode || 0,
-            body,
-            contentType,
-            hostname
-          })
-        );
-      }
-    );
-    req.on("error", () => resolve7(null));
-    req.setTimeout(timeout, () => {
-      req.destroy();
-      resolve7(null);
+    let settled = false;
+    const settle = (value) => {
+      if (settled) return;
+      settled = true;
+      resolve7(value);
+    };
+    const req = import_http.default.request({ hostname, port, path: path20, method, headers }, (res) => {
+      let body = "";
+      res.on("data", (c) => body += c.toString());
+      const contentType = (() => {
+        const raw = res.headers["content-type"];
+        if (typeof raw === "string") return raw;
+        if (Array.isArray(raw)) return raw[0];
+        return void 0;
+      })();
+      res.on(
+        "end",
+        () => settle({
+          statusCode: res.statusCode || 0,
+          body,
+          contentType,
+          hostname
+        })
+      );
     });
+    req.on("error", () => settle(null));
     req.end();
+    const giveUp = setTimeout(() => {
+      settle(null);
+      req.socket?.unref();
+    }, timeout);
+    const abandon = setTimeout(() => req.destroy(), BODY_TIMEOUT_MS);
+    abandon.unref?.();
+    req.on("close", () => {
+      clearTimeout(giveUp);
+      clearTimeout(abandon);
+      setImmediate(() => settle(null));
+    });
   });
 }
+function isOwnShellPort(port) {
+  const offset = Number(process.env.PORT_OFFSET) || 0;
+  if (port >= SELF_PORT_RANGE_START && port <= SELF_PORT_RANGE_END) return true;
+  return offset > 0 && port >= SELF_PORT_RANGE_START + offset && port <= SELF_PORT_RANGE_END + offset;
+}
 function acceptPort(port, excluded) {
   if (port <= 0 || port >= 2e4) return false;
   if (excluded.has(port)) return false;
-  if (port >= 5170 && port <= 5200) return false;
+  if (isOwnShellPort(port)) return false;
   return true;
 }
-async function discoverListeningProcesses(excludePorts = []) {
+function wasKilledByTimeout(err) {
+  return !!(err && typeof err === "object" && err.killed);
+}
+async function scanListeningProcesses(excludePorts = []) {
   const excluded = new Set(excludePorts);
+  let timedOut = false;
   try {
-    const { stdout } = await execP(
+    const { stdout } = await execGuarded(
       `lsof -iTCP -sTCP:LISTEN -P -n 2>/dev/null | grep -E '^(node|bun)'`,
-      { encoding: "utf8", timeout: 2e3 }
+      LISTING_TIMEOUT_MS
     );
-    if (stdout.trim()) {
-      const seen = /* @__PURE__ */ new Map();
-      for (const line of stdout.trim().split("\n")) {
-        const parts = line.trim().split(/\s+/);
-        if (parts.length < 9) continue;
-        const pid = Number(parts[1]);
-        const addr = parts[8];
-        const m = addr.match(/:(\d+)$/);
-        if (!m) continue;
-        const port = Number(m[1]);
-        if (!acceptPort(port, excluded)) continue;
-        if (!seen.has(port)) seen.set(port, pid);
-      }
-      if (seen.size > 0) {
-        return [...seen.entries()].map(([port, pid]) => ({ port, pid }));
-      }
+    const seen = /* @__PURE__ */ new Map();
+    for (const line of stdout.trim() ? stdout.trim().split("\n") : []) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 9) continue;
+      const pid = Number(parts[1]);
+      const addr = parts[8];
+      const m = addr.match(/:(\d+)$/);
+      if (!m) continue;
+      const port = Number(m[1]);
+      if (!acceptPort(port, excluded)) continue;
+      if (!seen.has(port)) seen.set(port, pid);
     }
-  } catch {
+    return {
+      state: "looked",
+      processes: [...seen.entries()].map(([port, pid]) => ({ port, pid }))
+    };
+  } catch (err) {
+    if (wasKilledByTimeout(err)) timedOut = true;
   }
   try {
-    const { stdout } = await execP(`ss -tlnp 2>/dev/null | grep -E '"(node|bun)"'`, {
-      encoding: "utf8",
-      timeout: 2e3
-    });
-    if (stdout.trim()) {
-      const seen = /* @__PURE__ */ new Map();
-      for (const line of stdout.trim().split("\n")) {
-        const portMatch = line.match(/:(\d+)\s/);
-        const pidMatch = line.match(/pid=(\d+)/);
-        if (!portMatch) continue;
-        const port = Number(portMatch[1]);
-        const pid = pidMatch ? Number(pidMatch[1]) : 0;
-        if (!acceptPort(port, excluded)) continue;
-        if (!seen.has(port)) seen.set(port, pid);
-      }
-      if (seen.size > 0) {
-        return [...seen.entries()].map(([port, pid]) => ({ port, pid }));
-      }
+    const { stdout } = await execGuarded(
+      `ss -tlnp 2>/dev/null | grep -E '"(node|bun)"'`,
+      LISTING_TIMEOUT_MS
+    );
+    const seen = /* @__PURE__ */ new Map();
+    for (const line of stdout.trim() ? stdout.trim().split("\n") : []) {
+      const portMatch = line.match(/:(\d+)\s/);
+      const pidMatch = line.match(/pid=(\d+)/);
+      if (!portMatch) continue;
+      const port = Number(portMatch[1]);
+      const pid = pidMatch ? Number(pidMatch[1]) : 0;
+      if (!acceptPort(port, excluded)) continue;
+      if (!seen.has(port)) seen.set(port, pid);
     }
-  } catch {
+    return {
+      state: "looked",
+      processes: [...seen.entries()].map(([port, pid]) => ({ port, pid }))
+    };
+  } catch (err) {
+    if (wasKilledByTimeout(err)) timedOut = true;
   }
-  return FALLBACK_PORTS.filter((p) => acceptPort(p.port, excluded));
+  if (timedOut) return { state: "could-not-look" };
+  return {
+    state: "looked",
+    processes: FALLBACK_PORTS.filter((p) => acceptPort(p.port, excluded))
+  };
 }
 function pidFromNetstat(stdout, port) {
   for (const line of stdout.split("\n")) {
@@ -15104,9 +15146,7 @@ function pidFromNetstat(stdout, port) {
 async function resolveListeningPid(port) {
   if (!Number.isInteger(port) || port <= 0) return null;
   try {
-    const { stdout } = await execP("netstat -anv -p tcp 2>/dev/null", {
-      encoding: "utf8",
-      timeout: 8e3,
+    const { stdout } = await execGuarded("netstat -anv -p tcp 2>/dev/null", 8e3, {
       maxBuffer: 16 * 1024 * 1024
     });
     const pid = pidFromNetstat(stdout, port);
@@ -15114,9 +15154,7 @@ async function resolveListeningPid(port) {
   } catch {
   }
   try {
-    const { stdout } = await execP(`ss -tlnp 2>/dev/null`, {
-      encoding: "utf8",
-      timeout: 8e3,
+    const { stdout } = await execGuarded(`ss -tlnp 2>/dev/null`, 8e3, {
       maxBuffer: 16 * 1024 * 1024
     });
     for (const line of stdout.split("\n")) {
@@ -15141,10 +15179,10 @@ async function resolveProcessCwd(pid) {
   } catch {
   }
   try {
-    const { stdout } = await execP(`lsof -b -w -p ${pid} -a -d cwd -Fn 2>/dev/null`, {
-      encoding: "utf8",
-      timeout: 8e3
-    });
+    const { stdout } = await execGuarded(
+      `lsof -b -w -p ${pid} -a -d cwd -Fn 2>/dev/null`,
+      8e3
+    );
     for (const line of stdout.split("\n")) {
       if (line.startsWith("n") && line.length > 1) {
         const cwd = line.slice(1).trim();
@@ -15306,7 +15344,8 @@ async function probePort(port, buildIconProxyUrl, listeningProcess) {
   const manifestParsed = manifestRes ? safeParseManifest(manifestRes.body) : null;
   const manifestLaunchUrl = typeof manifestParsed?.launchAsset?.url === "string" ? manifestParsed.launchAsset.url : null;
   const manifestClient = manifestParsed?.extra?.expoClient || manifestParsed?.extra || {};
-  if (manifestParsed && (manifestLaunchUrl || typeof manifestClient.name === "string")) {
+  const manifestState = !manifestRes ? "no-answer" : manifestParsed && (manifestLaunchUrl || typeof manifestClient.name === "string") ? "resolved" : "no-manifest";
+  if (manifestState === "resolved") {
     knownNonPatched.add(port);
     const launchUrl2 = manifestLaunchUrl || `${buildLoopbackProbeBaseUrl("http:", probeHostname, port)}/index.bundle?platform=ios&dev=true&hot=true&minify=false`;
     const framework = launchUrl2.includes(
@@ -15327,17 +15366,15 @@ async function probePort(port, buildIconProxyUrl, listeningProcess) {
   }
   if (statusRes && statusRes.body.includes("packager-status:running")) {
     knownNonPatched.add(port);
+    const result = makeResult(
+      probeHostname,
+      port,
+      expoRes && expoRes.statusCode === 200 ? "expo" : "metro",
+      owner
+    );
+    if (manifestState === "no-answer") result.bundleUrlProvisional = true;
     return enrichWithManifest(
-      applyManifest(
-        makeResult(
-          probeHostname,
-          port,
-          expoRes && expoRes.statusCode === 200 ? "expo" : "metro",
-          owner
-        ),
-        manifestRes,
-        buildIconProxyUrl
-      ),
+      applyManifest(result, manifestRes, buildIconProxyUrl),
       buildIconProxyUrl
     );
   }
@@ -15430,7 +15467,9 @@ async function attachAppSettingsBundle(result, projectRoot) {
 }
 async function scanDevServers(opts = {}) {
   await loadOptionalDemoApps();
-  const processes = await discoverListeningProcesses(opts.excludePorts);
+  const scan = await scanListeningProcesses(opts.excludePorts);
+  if (scan.state === "could-not-look") throw new DevServerScanUnavailableError();
+  const processes = scan.processes;
   const currentPorts = new Set(processes.map((p) => p.port));
   for (const p of [...portCache.keys()]) {
     if (!currentPorts.has(p)) portCache.delete(p);
@@ -15494,7 +15533,7 @@ async function scanDevServers(opts = {}) {
   }
   return results.filter((r) => !isSootSimSelfServer(r));
 }
-var import_child_process, import_promises2, import_http, import_net, import_node_path3, import_util, execP, TIMEOUT_MS, MANIFEST_TIMEOUT_MS, TCP_GATE_MS, FALLBACK_PORTS, cwdByPid, ENRICH_TIMEOUT_MS, enrichmentCache, enrichmentInFlight, knownNonPatched, knownNonExpo, knownOne, portCache, NEGATIVE_CACHE_TTL_MS, WEAK_RESULT_CACHE_TTL_MS;
+var import_child_process, import_promises2, import_http, import_net, import_node_path3, EXEC_EXIT_GRACE_MS, TIMEOUT_MS, MANIFEST_TIMEOUT_MS, TCP_GATE_MS, BODY_TIMEOUT_MS, FALLBACK_PORTS, SELF_PORT_RANGE_START, SELF_PORT_RANGE_END, DevServerScanUnavailableError, LISTING_TIMEOUT_MS, cwdByPid, ENRICH_TIMEOUT_MS, enrichmentCache, enrichmentInFlight, knownNonPatched, knownNonExpo, knownOne, portCache, NEGATIVE_CACHE_TTL_MS, WEAK_RESULT_CACHE_TTL_MS;
 var init_dev_server_scanner = __esm({
   "scripts/dev-server-scanner.ts"() {
     "use strict";
@@ -15503,16 +15542,16 @@ var init_dev_server_scanner = __esm({
     import_http = __toESM(require("http"), 1);
     import_net = __toESM(require("net"), 1);
     import_node_path3 = require("node:path");
-    import_util = require("util");
     init_backend_origin();
     init_config();
     init_native_dev_bundle_url();
     init_settings_bundle();
     init_optional_demo_registry();
-    execP = (0, import_util.promisify)(import_child_process.exec);
+    EXEC_EXIT_GRACE_MS = 2e3;
     TIMEOUT_MS = 250;
     MANIFEST_TIMEOUT_MS = 1500;
     TCP_GATE_MS = 120;
+    BODY_TIMEOUT_MS = 3e4;
     FALLBACK_PORTS = [
       8081,
       8082,
@@ -15524,6 +15563,15 @@ var init_dev_server_scanner = __esm({
       3001,
       19e3
     ].map((port) => ({ port, pid: 0 }));
+    SELF_PORT_RANGE_START = 5170;
+    SELF_PORT_RANGE_END = 5200;
+    DevServerScanUnavailableError = class extends Error {
+      constructor() {
+        super("could not enumerate listening processes (lsof/ss unavailable or timed out)");
+        this.name = "DevServerScanUnavailableError";
+      }
+    };
+    LISTING_TIMEOUT_MS = 1e4;
     cwdByPid = /* @__PURE__ */ new Map();
     ENRICH_TIMEOUT_MS = 2e4;
     enrichmentCache = /* @__PURE__ */ new Map();
@@ -18451,9 +18499,290 @@ var init_open_url = __esm({
   }
 });
 
+// cli/commands/box/checkout-plane.ts
+function looksBinary(filePath, size) {
+  if (size === 0) return false;
+  let fd;
+  try {
+    fd = import_node_fs9.default.openSync(filePath, "r");
+    const buffer = Buffer.alloc(Math.min(BINARY_SNIFF_BYTES, size));
+    const read = import_node_fs9.default.readSync(fd, buffer, 0, buffer.length, 0);
+    return buffer.subarray(0, read).includes(0);
+  } catch {
+    return false;
+  } finally {
+    if (fd !== void 0) import_node_fs9.default.closeSync(fd);
+  }
+}
+var import_node_child_process5, import_node_fs9, import_node_path10, CheckoutRequiresGitError, BINARY_SNIFF_BYTES, LIST_FILES_TIMEOUT_MS, CheckoutFilePlane;
+var init_checkout_plane = __esm({
+  "cli/commands/box/checkout-plane.ts"() {
+    "use strict";
+    import_node_child_process5 = require("node:child_process");
+    import_node_fs9 = __toESM(require("node:fs"), 1);
+    import_node_path10 = __toESM(require("node:path"), 1);
+    CheckoutRequiresGitError = class extends Error {
+    };
+    BINARY_SNIFF_BYTES = 8192;
+    LIST_FILES_TIMEOUT_MS = 1e4;
+    CheckoutFilePlane = class {
+      root;
+      entries = /* @__PURE__ */ new Map();
+      sniffed = /* @__PURE__ */ new Map();
+      // the deadline above, as a number a caller can set. what it changes is how
+      // long a wedged git is waited on, never whether it is waited on, so proving
+      // the kill does not have to cost the production deadline.
+      listTimeoutMs;
+      constructor(root, options = {}) {
+        this.root = import_node_path10.default.resolve(root);
+        this.listTimeoutMs = options.listTimeoutMs ?? LIST_FILES_TIMEOUT_MS;
+      }
+      index() {
+        return this.entries;
+      }
+      async refresh() {
+        let stdout;
+        try {
+          stdout = (0, import_node_child_process5.execFileSync)("git", ["ls-files", "-co", "--exclude-standard", "-z"], {
+            cwd: this.root,
+            encoding: "utf8",
+            maxBuffer: 64 * 1024 * 1024,
+            timeout: this.listTimeoutMs,
+            // stating the environment is not redundant here. bun 1.3.14 resolves
+            // the binary for the synchronous form against the PATH it captured at
+            // startup and ignores a later change to `process.env.PATH`, so without
+            // this it runs a different git than every other call in the process.
+            env: process.env
+          });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          const killed = error instanceof Error && "signal" in error && error.signal === "SIGTERM";
+          throw new CheckoutRequiresGitError(
+            killed ? `git did not list the project's files in ${this.root} within ${this.listTimeoutMs / 1e3}s, so the box has no file set to serve. the checkout may be on a stalled filesystem, or this machine may be too loaded to start a subprocess.` : `could not list the project's files with git in ${this.root}: ${message}`
+          );
+        }
+        if (stdout.length === 0) {
+          throw new CheckoutRequiresGitError(
+            `git listed no files in ${this.root}. either git tracks nothing there and nothing untracked is visible to it, or this machine could not read the child process's output.`
+          );
+        }
+        const next = /* @__PURE__ */ new Map();
+        const nextSniffed = /* @__PURE__ */ new Map();
+        for (const relative of stdout.split("\0")) {
+          if (!relative) continue;
+          let stat2;
+          try {
+            stat2 = import_node_fs9.default.statSync(import_node_path10.default.join(this.root, relative));
+          } catch {
+            continue;
+          }
+          if (!stat2.isFile()) continue;
+          const seen = this.sniffed.get(relative);
+          const binary = seen && seen.size === stat2.size && seen.mtimeMs === stat2.mtimeMs ? seen.binary : looksBinary(import_node_path10.default.join(this.root, relative), stat2.size);
+          nextSniffed.set(relative, { size: stat2.size, mtimeMs: stat2.mtimeMs, binary });
+          next.set(relative, {
+            size: stat2.size,
+            // a checkout carries no write policy of its own; if the user can write
+            // the file, so can the shell
+            readOnly: false,
+            binary
+          });
+        }
+        this.entries = next;
+        this.sniffed = nextSniffed;
+      }
+      absolute(planePath) {
+        const resolved = import_node_path10.default.resolve(this.root, planePath);
+        if (resolved !== this.root && !resolved.startsWith(`${this.root}${import_node_path10.default.sep}`)) {
+          throw new Error(`path escapes the project: ${planePath}`);
+        }
+        return resolved;
+      }
+      async read(planePath) {
+        return import_node_fs9.default.promises.readFile(this.absolute(planePath), "utf8");
+      }
+      async readBytes(planePath) {
+        return import_node_fs9.default.promises.readFile(this.absolute(planePath));
+      }
+      async write(planePath, content) {
+        const absolute = this.absolute(planePath);
+        await import_node_fs9.default.promises.mkdir(import_node_path10.default.dirname(absolute), { recursive: true });
+        await import_node_fs9.default.promises.writeFile(absolute, content);
+        this.entries.set(planePath, {
+          size: content.byteLength,
+          readOnly: false,
+          // the bytes are in hand, so the same NUL test costs nothing here
+          binary: content.subarray(0, BINARY_SNIFF_BYTES).includes(0)
+        });
+      }
+      async delete(planePath) {
+        await import_node_fs9.default.promises.rm(this.absolute(planePath), { force: true });
+        this.entries.delete(planePath);
+      }
+    };
+  }
+});
+
+// src/host/plane-host.ts
+var import_node_fs10, import_node_path11, import_plane, WS_OPEN2, PlaneNotRegisteredError, PlaneHost;
+var init_plane_host = __esm({
+  "src/host/plane-host.ts"() {
+    "use strict";
+    import_node_fs10 = __toESM(require("node:fs"), 1);
+    import_node_path11 = __toESM(require("node:path"), 1);
+    import_plane = require("@contrast/harness/plane");
+    init_checkout_plane();
+    WS_OPEN2 = 1;
+    PlaneNotRegisteredError = class extends Error {
+    };
+    PlaneHost = class {
+      // roots a box authorized, each tied to the socket that authorized it
+      registered = /* @__PURE__ */ new Map();
+      open = /* @__PURE__ */ new Map();
+      byRoot = /* @__PURE__ */ new Map();
+      nextPlaneId = 1;
+      /** handle a plane:* message. returns true iff it was one. */
+      async handleMessage(ws, msg) {
+        if (typeof msg !== "object" || msg === null) return false;
+        const record = { ...msg };
+        const type = record.type;
+        if (typeof type !== "string" || !type.startsWith("plane:")) return false;
+        const id = record.id;
+        try {
+          this.respond(ws, id, await this.dispatch(ws, type, record));
+        } catch (err) {
+          const code = err instanceof PlaneNotRegisteredError ? "plane-not-registered" : void 0;
+          this.respondError(ws, id, err instanceof Error ? err.message : String(err), code);
+        }
+        return true;
+      }
+      unregisterSocket(ws) {
+        for (const [root, sockets] of [...this.registered]) {
+          if (!sockets.delete(ws)) continue;
+          if (sockets.size > 0) continue;
+          this.registered.delete(root);
+          const planeId = this.byRoot.get(root);
+          if (planeId) {
+            this.open.delete(planeId);
+            this.byRoot.delete(root);
+          }
+        }
+        for (const [planeId, entry] of [...this.open]) {
+          entry.sockets.delete(ws);
+          if (entry.sockets.size === 0 && !this.registered.has(entry.root)) {
+            this.open.delete(planeId);
+            this.byRoot.delete(entry.root);
+          }
+        }
+      }
+      /** roots currently reachable, for the daemon's status output. */
+      registeredRoots() {
+        return [...this.registered.keys()];
+      }
+      async dispatch(ws, type, msg) {
+        switch (type) {
+          case "plane:register": {
+            const root = this.realRoot(String(msg.root ?? ""));
+            const sockets = this.registered.get(root) ?? /* @__PURE__ */ new Set();
+            sockets.add(ws);
+            this.registered.set(root, sockets);
+            return { root, holders: sockets.size };
+          }
+          // READ ONLY, and that is the whole point of it existing beside the
+          // `holders` field on plane:register.
+          //
+          // registration is the AUTHORIZATION step: it is what permits any page on
+          // this machine to open that root over a loopback socket that CORS does
+          // not protect. so a caller asking "is anyone else in this checkout"
+          // cannot be made to authorize the root in order to find out, even
+          // briefly. it also means the count is the honest one: no box reads 0 and
+          // a single box reads 1, where asking through register would have made
+          // every answer one higher and forced a threshold that counts the asker.
+          case "plane:status": {
+            const root = this.realRoot(String(msg.root ?? ""));
+            const sockets = this.registered.get(root);
+            return { root, holders: sockets?.size ?? 0, registered: Boolean(sockets) };
+          }
+          case "plane:open": {
+            const root = this.realRoot(String(msg.root ?? ""));
+            if (!this.registered.has(root)) {
+              throw new PlaneNotRegisteredError(
+                `no box has registered ${root}; start one with \`rnx box\` there`
+              );
+            }
+            const existingId = this.byRoot.get(root);
+            const existing = existingId ? this.open.get(existingId) : void 0;
+            if (existingId && existing) {
+              existing.sockets.add(ws);
+              return { planeId: existingId, version: existing.version };
+            }
+            const plane = new CheckoutFilePlane(root);
+            await plane.refresh();
+            const planeId = `plane-${this.nextPlaneId++}`;
+            const entry = {
+              root,
+              plane,
+              version: (0, import_plane.indexVersion)(plane.index()),
+              sockets: /* @__PURE__ */ new Set([ws])
+            };
+            this.open.set(planeId, entry);
+            this.byRoot.set(root, planeId);
+            return { planeId, version: entry.version };
+          }
+          case "plane:close": {
+            const entry = this.open.get(String(msg.planeId ?? ""));
+            if (entry) entry.sockets.delete(ws);
+            return { ok: true };
+          }
+          default: {
+            const entry = this.entry(msg);
+            const handled = await (0, import_plane.dispatchPlaneCommand)(entry.plane, type, msg);
+            if (!handled) throw new Error(`unknown plane command: ${type}`);
+            if (handled.version) entry.version = handled.version;
+            return handled.result;
+          }
+        }
+      }
+      entry(msg) {
+        const entry = this.open.get(String(msg.planeId ?? ""));
+        if (!entry) throw new Error(`unknown planeId: ${String(msg.planeId)}`);
+        return entry;
+      }
+      // resolve symlinks and relative segments before comparing, so a registered
+      // root and an opened one cannot disagree about the same directory.
+      realRoot(root) {
+        if (!root) throw new Error("root is required");
+        const resolved = import_node_path11.default.resolve(root);
+        let real;
+        try {
+          real = import_node_fs10.default.realpathSync(resolved);
+        } catch {
+          throw new Error(`no such directory: ${resolved}`);
+        }
+        if (!import_node_fs10.default.statSync(real).isDirectory()) throw new Error(`not a directory: ${real}`);
+        return real;
+      }
+      respond(ws, id, result) {
+        if (ws.readyState !== WS_OPEN2) return;
+        try {
+          ws.send(JSON.stringify({ id, result }));
+        } catch {
+        }
+      }
+      respondError(ws, id, error, code) {
+        if (ws.readyState !== WS_OPEN2) return;
+        try {
+          ws.send(JSON.stringify({ id, error, ...code ? { code } : {} }));
+        } catch {
+        }
+      }
+    };
+  }
+});
+
 // src/host/replacement-module-handler.ts
 function getReplacementLoader(filePath) {
-  const ext = import_node_path10.default.extname(filePath).toLowerCase();
+  const ext = import_node_path12.default.extname(filePath).toLowerCase();
   switch (ext) {
     case ".js":
       return "js";
@@ -18535,7 +18864,7 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
     res.end("replacement files must be .js, .jsx, .ts, or .tsx");
     return true;
   }
-  if (!import_node_path10.default.isAbsolute(targetPath)) {
+  if (!import_node_path12.default.isAbsolute(targetPath)) {
     res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
     res.end("replacement file path must be absolute");
     return true;
@@ -18543,10 +18872,10 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
   const runtimePackages = new Set(url.searchParams.getAll("runtimePackage"));
   let resolvedProjectRoot;
   if (options.projectRoot) {
-    const lexicalProjectRoot = import_node_path10.default.resolve(options.projectRoot);
+    const lexicalProjectRoot = import_node_path12.default.resolve(options.projectRoot);
     resolvedProjectRoot = await import_promises5.default.realpath(options.projectRoot);
-    const lexicalTarget = import_node_path10.default.relative(lexicalProjectRoot, targetPath);
-    if (lexicalTarget.startsWith("..") || import_node_path10.default.isAbsolute(lexicalTarget)) {
+    const lexicalTarget = import_node_path12.default.relative(lexicalProjectRoot, targetPath);
+    if (lexicalTarget.startsWith("..") || import_node_path12.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;
@@ -18562,8 +18891,8 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
     return true;
   }
   if (resolvedProjectRoot) {
-    const relativeTarget = import_node_path10.default.relative(resolvedProjectRoot, resolvedTargetPath);
-    if (relativeTarget.startsWith("..") || import_node_path10.default.isAbsolute(relativeTarget)) {
+    const relativeTarget = import_node_path12.default.relative(resolvedProjectRoot, resolvedTargetPath);
+    if (relativeTarget.startsWith("..") || import_node_path12.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;
@@ -18648,12 +18977,12 @@ exports.jsxDEV = exports.jsx`,
   }
   return true;
 }
-var import_promises5, import_node_path10, import_esbuild, REPLACEMENT_MODULE_ROUTE;
+var import_promises5, import_node_path12, import_esbuild, REPLACEMENT_MODULE_ROUTE;
 var init_replacement_module_handler = __esm({
   "src/host/replacement-module-handler.ts"() {
     "use strict";
     import_promises5 = __toESM(require("node:fs/promises"), 1);
-    import_node_path10 = __toESM(require("node:path"), 1);
+    import_node_path12 = __toESM(require("node:path"), 1);
     import_esbuild = require("esbuild");
     init_backend_origin();
     REPLACEMENT_MODULE_ROUTE = "/__sootsim-replacement-module";
@@ -18900,6 +19229,7 @@ var init_bridge_host = __esm({
     init_agent_host();
     init_fetch_proxy_handler();
     init_open_url();
+    init_plane_host();
     init_replacement_module_handler();
     init_websocket_proxy();
     SOOTSIM_CROSS_ORIGIN_EMBEDDER_POLICY = "require-corp";
@@ -18964,6 +19294,7 @@ var init_bridge_host = __esm({
       nextCliFallbackId = 1;
       cliIdleTimer = null;
       agentHost;
+      planeHost = new PlaneHost();
       static CLI_IDLE_TIMEOUT_MS = 6e4;
       static CLI_LEASE_TTL_MS = 6e5;
       static USER_ACTIVE_LEASE_TTL_MS = 8e3;
@@ -19195,6 +19526,10 @@ var init_bridge_host = __esm({
               void this.agentHost.handleMessage(ws, msg);
               return;
             }
+            if (typeof msg.type === "string" && msg.type.startsWith("plane:")) {
+              void this.planeHost.handleMessage(ws, msg);
+              return;
+            }
             if (msg.type === "runtime:list") {
               const versions = sootsimRuntime.listInstalled();
               const active = this.getActiveRuntime();
@@ -19517,6 +19852,7 @@ var init_bridge_host = __esm({
           });
           ws.on("close", () => {
             this.agentHost.unregisterSocket(ws);
+            this.planeHost.unregisterSocket(ws);
             if (role === "sim" && sim) {
               this.rememberDisconnectedSim(sim);
               if (this.primarySimId === sim.id) {
@@ -21214,17 +21550,17 @@ function liveDevBridgeLockfiles() {
   return readDevBridgeLockfiles().filter((lockfile) => isDevBridgeLockfileFresh(lockfile));
 }
 function checkoutRoot(cwd) {
-  let current = import_node_path11.default.resolve(cwd);
+  let current = import_node_path13.default.resolve(cwd);
   while (true) {
-    if (import_node_fs9.default.existsSync(import_node_path11.default.join(current, ".git"))) return current;
-    const parent = import_node_path11.default.dirname(current);
+    if (import_node_fs11.default.existsSync(import_node_path13.default.join(current, ".git"))) return current;
+    const parent = import_node_path13.default.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function pathContains(parent, child) {
-  const relative = import_node_path11.default.relative(parent, child);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${import_node_path11.default.sep}`) && !import_node_path11.default.isAbsolute(relative);
+  const relative = import_node_path13.default.relative(parent, child);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${import_node_path13.default.sep}`) && !import_node_path13.default.isAbsolute(relative);
 }
 function resolveDefaultDevBridgeLockfile() {
   const lockfiles = liveDevBridgeLockfiles();
@@ -21647,18 +21983,18 @@ async function evalInBridge(bridge, code, opts = {}) {
   if (opts.acquireLock) payload.acquireLock = true;
   return bridge.send(payload);
 }
-async function callInBridge(bridge, path18, ...args) {
-  return bridge.send({ type: "call", path: path18, args });
+async function callInBridge(bridge, path20, ...args) {
+  return bridge.send({ type: "call", path: path20, args });
 }
-async function callInBridgeWrite(bridge, path18, ...args) {
-  return bridge.send({ type: "call", path: path18, args, acquireLock: true });
+async function callInBridgeWrite(bridge, path20, ...args) {
+  return bridge.send({ type: "call", path: path20, args, acquireLock: true });
 }
-var import_node_fs9, import_node_path11, import_ws3, RNX_PLACEMENT_ENV, resolvedWorld, BridgeSimLockedError;
+var import_node_fs11, import_node_path13, import_ws3, RNX_PLACEMENT_ENV, resolvedWorld, BridgeSimLockedError;
 var init_ws_bridge = __esm({
   "cli/ws-bridge.ts"() {
     "use strict";
-    import_node_fs9 = __toESM(require("node:fs"), 1);
-    import_node_path11 = __toESM(require("node:path"), 1);
+    import_node_fs11 = __toESM(require("node:fs"), 1);
+    import_node_path13 = __toESM(require("node:path"), 1);
     import_ws3 = require("ws");
     init_bridge_constants();
     init_cli_constants();
@@ -21753,8 +22089,8 @@ function getDefaultPortForProtocol(protocol) {
   return protocol === "https:" ? 443 : 80;
 }
 function isBaseServerUrl(url) {
-  const path18 = url.pathname || "/";
-  return (path18 === "/" || path18 === "") && !url.search && !url.hash;
+  const path20 = url.pathname || "/";
+  return (path20 === "/" || path20 === "") && !url.search && !url.hash;
 }
 async function resolvePortViaServerScan(port) {
   try {
@@ -21768,6 +22104,7 @@ async function resolvePortViaServerScan(port) {
       (s) => !!s && typeof s === "object" && s.port === port && typeof s.bundleUrl === "string"
     );
     if (!match) return null;
+    if (match.bundleUrlProvisional) return null;
     return {
       // normalize exactly like the manifest-probe branch below — the scan
       // returns metro's manifest launchAsset url (lazy=true for code-split
@@ -21783,45 +22120,76 @@ async function resolvePortViaServerScan(port) {
     return null;
   }
 }
-async function probeBaseUrlBundleDirect(baseUrl, port) {
-  const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
+async function probeExpoManifest(normalizedBaseUrl, port) {
+  let body;
+  const pending = fetchDevProbe(`${normalizedBaseUrl}/`, {
+    headers: { "expo-platform": "ios" }
+  }).then(
+    async (res) => res.ok ? { ok: true, body: await res.text() } : null,
+    () => void 0
+  );
+  const answered = await Promise.race([
+    pending,
+    new Promise(
+      (resolve7) => setTimeout(() => resolve7("timeout"), MANIFEST_PROBE_TIMEOUT_MS).unref?.()
+    )
+  ]);
+  if (answered === "timeout" || answered === void 0) return { state: "no-answer" };
+  if (answered === null) return { state: "no-manifest" };
+  body = answered.body;
+  if (!body.trim()) return { state: "no-answer" };
+  let manifest;
   try {
-    const manifestRes = await fetchDevProbe(`${normalizedBaseUrl}/`, {
-      headers: { "expo-platform": "ios" }
-    });
-    if (manifestRes.ok) {
-      const manifest = await manifestRes.json();
-      const client = manifest?.extra?.expoClient || manifest?.extra || {};
-      const rawLaunchUrl = typeof manifest?.launchAsset?.url === "string" ? manifest.launchAsset.url : void 0;
-      const launchUrl2 = rawLaunchUrl ? alignLoopbackBundleUrlWithProbe(rawLaunchUrl, normalizedBaseUrl) : void 0;
-      if (launchUrl2 || client.name) {
-        return {
-          bundleUrl: normalizeNativeDevBundleUrl(
-            launchUrl2 || `${normalizedBaseUrl}${METRO_BUNDLE_PATH}`
-          ),
-          port,
-          framework: inferManifestFramework(launchUrl2, client.sdkVersion),
-          projectName: client.name
-        };
-      }
-    }
+    manifest = JSON.parse(body);
   } catch {
+    return { state: "no-manifest" };
   }
-  try {
-    const statusRes = await fetchDevProbe(`${normalizedBaseUrl}/status`);
-    if (statusRes.ok) {
-      const text = await statusRes.text();
-      if (text.includes("packager-status:running")) {
-        return {
-          bundleUrl: `${normalizedBaseUrl}${METRO_BUNDLE_PATH}`,
-          port,
-          framework: "metro"
-        };
-      }
+  const client = manifest?.extra?.expoClient || manifest?.extra || {};
+  const rawLaunchUrl = typeof manifest?.launchAsset?.url === "string" ? manifest.launchAsset.url : void 0;
+  const launchUrl2 = rawLaunchUrl ? alignLoopbackBundleUrlWithProbe(rawLaunchUrl, normalizedBaseUrl) : void 0;
+  if (!launchUrl2 && !client.name) return { state: "no-manifest" };
+  return {
+    state: "resolved",
+    bundle: {
+      bundleUrl: normalizeNativeDevBundleUrl(
+        launchUrl2 || `${normalizedBaseUrl}${METRO_BUNDLE_PATH}`
+      ),
+      port,
+      framework: inferManifestFramework(launchUrl2, client.sdkVersion),
+      projectName: client.name
     }
+  };
+}
+async function isPackagerRunning(normalizedBaseUrl) {
+  try {
+    const res = await fetchDevProbe(`${normalizedBaseUrl}/status`);
+    if (!res.ok) return false;
+    return (await res.text()).includes("packager-status:running");
   } catch {
+    return false;
   }
-  return null;
+}
+async function probeBaseUrlBundleDirect(baseUrl, port) {
+  const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
+  let manifest = await probeExpoManifest(normalizedBaseUrl, port);
+  let packagerConfirmed = false;
+  if (manifest.state === "no-answer") {
+    packagerConfirmed = await isPackagerRunning(normalizedBaseUrl);
+    if (!packagerConfirmed) return null;
+    const deadline = Date.now() + MANIFEST_BOOT_BUDGET_MS;
+    while (manifest.state === "no-answer" && Date.now() < deadline) {
+      await new Promise((resolve7) => setTimeout(resolve7, MANIFEST_BOOT_RETRY_MS));
+      manifest = await probeExpoManifest(normalizedBaseUrl, port);
+    }
+  }
+  if (manifest.state === "resolved") return manifest.bundle;
+  if (manifest.state === "no-answer") return null;
+  if (!packagerConfirmed && !await isPackagerRunning(normalizedBaseUrl)) return null;
+  return {
+    bundleUrl: `${normalizedBaseUrl}${METRO_BUNDLE_PATH}`,
+    port,
+    framework: "metro"
+  };
 }
 async function probeBaseUrlBundle(baseUrl, port) {
   try {
@@ -21870,11 +22238,15 @@ async function resolveConnectionInput(input) {
   }
   return { bundleUrl: parsed.toString(), port, framework: "unknown" };
 }
+var MANIFEST_PROBE_TIMEOUT_MS, MANIFEST_BOOT_BUDGET_MS, MANIFEST_BOOT_RETRY_MS;
 var init_dev_bundle_resolution = __esm({
   "src/dev-bundle-resolution.ts"() {
     "use strict";
     init_backend_origin();
     init_native_dev_bundle_url();
+    MANIFEST_PROBE_TIMEOUT_MS = 5e3;
+    MANIFEST_BOOT_BUDGET_MS = 3e4;
+    MANIFEST_BOOT_RETRY_MS = 1e3;
   }
 });
 
@@ -21985,9 +22357,9 @@ var init_profiles = __esm({
 // cli/app-project.ts
 function firstNamedFile(dir, names) {
   for (const name2 of names) {
-    const candidate = import_node_path12.default.join(dir, name2);
+    const candidate = import_node_path14.default.join(dir, name2);
     try {
-      if (import_node_fs10.default.statSync(candidate).isFile()) return candidate;
+      if (import_node_fs12.default.statSync(candidate).isFile()) return candidate;
     } catch {
     }
   }
@@ -22000,24 +22372,24 @@ function findSootSimAppConfig(dir) {
   return firstNamedFile(dir, SOOTSIM_APP_CONFIG_NAMES);
 }
 function resolveAppProject(projectRoot) {
-  const appDir = import_node_path12.default.resolve(projectRoot);
+  const appDir = import_node_path14.default.resolve(projectRoot);
   try {
-    if (!import_node_fs10.default.statSync(appDir).isDirectory()) return null;
+    if (!import_node_fs12.default.statSync(appDir).isDirectory()) return null;
   } catch {
     return null;
   }
   const configPath = findSootSimAppConfig(appDir);
-  if (!configPath && !findExpoAppConfig(appDir) && !import_node_fs10.default.existsSync(import_node_path12.default.join(appDir, "package.json"))) {
+  if (!configPath && !findExpoAppConfig(appDir) && !import_node_fs12.default.existsSync(import_node_path14.default.join(appDir, "package.json"))) {
     return null;
   }
   return { appDir, configPath };
 }
-var import_node_fs10, import_node_path12, EXPO_APP_CONFIG_NAMES, SOOTSIM_APP_CONFIG_NAMES;
+var import_node_fs12, import_node_path14, EXPO_APP_CONFIG_NAMES, SOOTSIM_APP_CONFIG_NAMES;
 var init_app_project = __esm({
   "cli/app-project.ts"() {
     "use strict";
-    import_node_fs10 = __toESM(require("node:fs"), 1);
-    import_node_path12 = __toESM(require("node:path"), 1);
+    import_node_fs12 = __toESM(require("node:fs"), 1);
+    import_node_path14 = __toESM(require("node:path"), 1);
     EXPO_APP_CONFIG_NAMES = [
       "app.config.js",
       "app.config.ts",
@@ -22046,13 +22418,13 @@ function isSootSimConfig(value) {
 }
 function resolveConfigReplacementFiles(config, configPath) {
   if (!config.modules) return config;
-  const configDir = import_node_path13.default.dirname(configPath);
+  const configDir = import_node_path15.default.dirname(configPath);
   return {
     ...config,
     modules: Object.fromEntries(
       Object.entries(config.modules).map(([name2, resolution]) => [
         name2,
-        resolution && typeof resolution === "object" && "file" in resolution ? { ...resolution, file: import_node_path13.default.resolve(configDir, resolution.file) } : resolution
+        resolution && typeof resolution === "object" && "file" in resolution ? { ...resolution, file: import_node_path15.default.resolve(configDir, resolution.file) } : resolution
       ])
     )
   };
@@ -22082,12 +22454,12 @@ async function resolveSootSimAppConfig(startDir = process.cwd()) {
   const project = resolveAppProject(startDir);
   return { project, config: await loadSootSimAppConfig(project) };
 }
-var import_node_module, import_node_path13, import_jiti, require2;
+var import_node_module, import_node_path15, import_jiti, require2;
 var init_app_config = __esm({
   "cli/app-config.ts"() {
     "use strict";
     import_node_module = require("node:module");
-    import_node_path13 = __toESM(require("node:path"), 1);
+    import_node_path15 = __toESM(require("node:path"), 1);
     init_src();
     import_jiti = require("jiti");
     init_public_brand();
@@ -22155,13 +22527,13 @@ function discoverNativeLinkedAppFonts(opts) {
       scannedFontDirectories++;
       let entries;
       try {
-        entries = import_node_fs11.default.readdirSync(current.dir, { withFileTypes: true });
+        entries = import_node_fs13.default.readdirSync(current.dir, { withFileTypes: true });
       } catch {
         continue;
       }
       for (const entry of entries) {
         if (entry.isSymbolicLink()) continue;
-        const fullPath = import_node_path14.default.join(current.dir, entry.name);
+        const fullPath = import_node_path16.default.join(current.dir, entry.name);
         if (entry.isDirectory()) {
           if (current.depth < 4 && pending.length < 64 && !entry.name.startsWith(".")) {
             pending.push({ dir: fullPath, depth: current.depth + 1 });
@@ -22169,15 +22541,15 @@ function discoverNativeLinkedAppFonts(opts) {
           continue;
         }
         if (!entry.isFile() || !/\.(ttf|otf|woff|woff2)$/i.test(entry.name)) continue;
-        const relative = import_node_path14.default.relative(root, fullPath).split(import_node_path14.default.sep).join("/");
-        fontPaths.push(import_node_path14.default.posix.join(metroPathPrefix, relative));
+        const relative = import_node_path16.default.relative(root, fullPath).split(import_node_path16.default.sep).join("/");
+        fontPaths.push(import_node_path16.default.posix.join(metroPathPrefix, relative));
         if (fontPaths.length >= 256) break;
       }
     }
   };
   try {
     const packageJson = JSON.parse(
-      import_node_fs11.default.readFileSync(import_node_path14.default.join(selectedAppDir, "package.json"), "utf8")
+      import_node_fs13.default.readFileSync(import_node_path16.default.join(selectedAppDir, "package.json"), "utf8")
     );
     const dependencyNames = /* @__PURE__ */ new Set();
     for (const field of ["dependencies", "devDependencies", "optionalDependencies"]) {
@@ -22192,24 +22564,24 @@ function discoverNativeLinkedAppFonts(opts) {
       const config = Reflect.get(packageJson, "reactNativeVectorIcons");
       const configuredFontDir = config && typeof config === "object" ? Reflect.get(config, "fontDir") : null;
       const configuredDir = typeof configuredFontDir === "string" ? configuredFontDir : "rnvi-fonts";
-      const root = import_node_path14.default.resolve(selectedAppDir, configuredDir);
-      const relativeRoot = import_node_path14.default.relative(selectedAppDir, root);
-      if (!relativeRoot.startsWith("..") && !import_node_path14.default.isAbsolute(relativeRoot)) {
-        collectFontFiles(root, relativeRoot.split(import_node_path14.default.sep).join("/"));
+      const root = import_node_path16.default.resolve(selectedAppDir, configuredDir);
+      const relativeRoot = import_node_path16.default.relative(selectedAppDir, root);
+      if (!relativeRoot.startsWith("..") && !import_node_path16.default.isAbsolute(relativeRoot)) {
+        collectFontFiles(root, relativeRoot.split(import_node_path16.default.sep).join("/"));
       }
-      const vectorIconRequire = (0, import_node_module2.createRequire)(import_node_path14.default.join(selectedAppDir, "package.json"));
+      const vectorIconRequire = (0, import_node_module2.createRequire)(import_node_path16.default.join(selectedAppDir, "package.json"));
       for (const dependencyName of vectorIconDependencies) {
         try {
           const entryPath = vectorIconRequire.resolve(dependencyName);
-          const dependencyPath = dependencyName.split("/").join(import_node_path14.default.sep);
-          const marker = `${import_node_path14.default.sep}node_modules${import_node_path14.default.sep}${dependencyPath}${import_node_path14.default.sep}`;
+          const dependencyPath = dependencyName.split("/").join(import_node_path16.default.sep);
+          const marker = `${import_node_path16.default.sep}node_modules${import_node_path16.default.sep}${dependencyPath}${import_node_path16.default.sep}`;
           const markerIndex = entryPath.lastIndexOf(marker);
           if (markerIndex === -1) continue;
           const packageRoot = entryPath.slice(0, markerIndex + marker.length - 1);
           const fontsDir = dependencyName === "react-native-vector-icons" ? "Fonts" : "fonts";
           collectFontFiles(
-            import_node_path14.default.join(packageRoot, fontsDir),
-            import_node_path14.default.posix.join("node_modules", dependencyName, fontsDir)
+            import_node_path16.default.join(packageRoot, fontsDir),
+            import_node_path16.default.posix.join("node_modules", dependencyName, fontsDir)
           );
         } catch {
         }
@@ -22218,37 +22590,37 @@ function discoverNativeLinkedAppFonts(opts) {
   } catch {
   }
   try {
-    const configPath = import_node_path14.default.join(selectedAppDir, "react-native.config.js");
-    if (import_node_fs11.default.statSync(configPath).isFile()) {
-      const appConfigRequire = (0, import_node_module2.createRequire)(import_node_path14.default.join(selectedAppDir, "package.json"));
+    const configPath = import_node_path16.default.join(selectedAppDir, "react-native.config.js");
+    if (import_node_fs13.default.statSync(configPath).isFile()) {
+      const appConfigRequire = (0, import_node_module2.createRequire)(import_node_path16.default.join(selectedAppDir, "package.json"));
       const rnConfig = appConfigRequire(configPath);
       const assets = rnConfig && typeof rnConfig === "object" ? Reflect.get(rnConfig, "assets") : null;
       if (Array.isArray(assets)) {
         for (const assetDir of assets) {
           if (typeof assetDir !== "string") continue;
-          const root = import_node_path14.default.resolve(selectedAppDir, assetDir);
-          const relativeRoot = import_node_path14.default.relative(selectedAppDir, root);
-          if (relativeRoot.startsWith("..") || import_node_path14.default.isAbsolute(relativeRoot)) continue;
-          collectFontFiles(root, relativeRoot.split(import_node_path14.default.sep).join("/"));
+          const root = import_node_path16.default.resolve(selectedAppDir, assetDir);
+          const relativeRoot = import_node_path16.default.relative(selectedAppDir, root);
+          if (relativeRoot.startsWith("..") || import_node_path16.default.isAbsolute(relativeRoot)) continue;
+          collectFontFiles(root, relativeRoot.split(import_node_path16.default.sep).join("/"));
         }
       }
     }
   } catch {
   }
   if (platform === "ios") {
-    const iosDir = import_node_path14.default.join(selectedAppDir, "ios");
+    const iosDir = import_node_path16.default.join(selectedAppDir, "ios");
     try {
-      const targetDirs = import_node_fs11.default.readdirSync(iosDir, { withFileTypes: true }).filter(
+      const targetDirs = import_node_fs13.default.readdirSync(iosDir, { withFileTypes: true }).filter(
         (entry) => entry.isDirectory() && !entry.isSymbolicLink() && entry.name !== "Pods" && entry.name !== "build" && !entry.name.startsWith(".")
       ).slice(0, 64);
-      const plistPaths = [import_node_path14.default.join(iosDir, "Info.plist")];
+      const plistPaths = [import_node_path16.default.join(iosDir, "Info.plist")];
       for (const entry of targetDirs) {
-        plistPaths.push(import_node_path14.default.join(iosDir, entry.name, "Info.plist"));
+        plistPaths.push(import_node_path16.default.join(iosDir, entry.name, "Info.plist"));
       }
       for (const plistPath of plistPaths) {
         let parsed;
         try {
-          parsed = parsePlistSource(import_node_fs11.default.readFileSync(plistPath, "utf8"));
+          parsed = parsePlistSource(import_node_fs13.default.readFileSync(plistPath, "utf8"));
         } catch {
           continue;
         }
@@ -22258,21 +22630,21 @@ function discoverNativeLinkedAppFonts(opts) {
         for (const declaredFont of declaredFonts) {
           if (typeof declaredFont !== "string") continue;
           const candidates = [
-            import_node_path14.default.resolve(import_node_path14.default.dirname(plistPath), declaredFont),
-            import_node_path14.default.resolve(iosDir, declaredFont)
+            import_node_path16.default.resolve(import_node_path16.default.dirname(plistPath), declaredFont),
+            import_node_path16.default.resolve(iosDir, declaredFont)
           ];
           const fontPath = candidates.find((candidate) => {
-            const relative = import_node_path14.default.relative(selectedAppDir, candidate);
-            if (relative.startsWith("..") || import_node_path14.default.isAbsolute(relative)) return false;
+            const relative = import_node_path16.default.relative(selectedAppDir, candidate);
+            if (relative.startsWith("..") || import_node_path16.default.isAbsolute(relative)) return false;
             try {
-              return import_node_fs11.default.statSync(candidate).isFile();
+              return import_node_fs13.default.statSync(candidate).isFile();
             } catch {
               return false;
             }
           });
           if (!fontPath) continue;
           fontPaths.push(
-            import_node_path14.default.relative(selectedAppDir, fontPath).split(import_node_path14.default.sep).join("/")
+            import_node_path16.default.relative(selectedAppDir, fontPath).split(import_node_path16.default.sep).join("/")
           );
         }
       }
@@ -22311,13 +22683,13 @@ async function resolveMetroProjectRoot(bundleUrl, opts) {
 function encodeAppFontsWire(specs) {
   return specs.map((spec) => `${encodeURIComponent(spec.url)}::${encodeURIComponent(spec.family)}`).join(",");
 }
-var import_node_fs11, import_node_module2, import_node_path14, import_config_plugin_fonts, require3;
+var import_node_fs13, import_node_module2, import_node_path16, import_config_plugin_fonts, require3;
 var init_app_fonts = __esm({
   "cli/app-fonts.ts"() {
     "use strict";
-    import_node_fs11 = __toESM(require("node:fs"), 1);
+    import_node_fs13 = __toESM(require("node:fs"), 1);
     import_node_module2 = require("node:module");
-    import_node_path14 = __toESM(require("node:path"), 1);
+    import_node_path16 = __toESM(require("node:path"), 1);
     import_config_plugin_fonts = require("sootsim-engine/engine/config-plugin-fonts");
     init_dev_server_scanner();
     init_plist();
@@ -23408,7 +23780,7 @@ function resolvePlaywright() {
         try {
           const modulePath = requireFromRoot.resolve(spec);
           const packageJsonPath = requireFromRoot.resolve(`${spec}/package.json`);
-          const parsed = JSON.parse((0, import_node_fs12.readFileSync)(packageJsonPath, "utf8"));
+          const parsed = JSON.parse((0, import_node_fs14.readFileSync)(packageJsonPath, "utf8"));
           if (!isRecord3(parsed) || typeof parsed.version !== "string") continue;
           const bin = parsed.bin;
           let binPath = null;
@@ -23420,8 +23792,8 @@ function resolvePlaywright() {
             binPath = typeof named === "string" ? named : typeof first === "string" ? first : null;
           }
           if (!binPath) continue;
-          const cliPath = (0, import_node_path15.join)((0, import_node_path15.dirname)(packageJsonPath), binPath);
-          if (!(0, import_node_fs12.existsSync)(cliPath)) continue;
+          const cliPath = (0, import_node_path17.join)((0, import_node_path17.dirname)(packageJsonPath), binPath);
+          if (!(0, import_node_fs14.existsSync)(cliPath)) continue;
           return {
             spec,
             modulePath,
@@ -23437,7 +23809,7 @@ function resolvePlaywright() {
   return null;
 }
 function probeBrowser(resolved, env) {
-  const probe3 = (0, import_node_child_process5.spawnSync)(process.execPath, ["-e", PLAYWRIGHT_BROWSER_PROBE], {
+  const probe3 = (0, import_node_child_process6.spawnSync)(process.execPath, ["-e", PLAYWRIGHT_BROWSER_PROBE], {
     env: {
       ...env,
       SOOTSIM_PW_MODULE: resolved.modulePath
@@ -23460,7 +23832,7 @@ function probeBrowser(resolved, env) {
     return {
       ok: true,
       executablePath: parsed.executablePath,
-      exists: parsed.exists && (0, import_node_fs12.existsSync)(parsed.executablePath)
+      exists: parsed.exists && (0, import_node_fs14.existsSync)(parsed.executablePath)
     };
   } catch (error) {
     return {
@@ -23475,7 +23847,7 @@ function ensurePlaywrightBrowser(resolved, env = process.env) {
   if (before.exists) {
     return { ok: true, executablePath: before.executablePath, installed: false };
   }
-  const install = (0, import_node_child_process5.spawnSync)(process.execPath, [resolved.cliPath, "install", "chromium"], {
+  const install = (0, import_node_child_process6.spawnSync)(process.execPath, [resolved.cliPath, "install", "chromium"], {
     env,
     encoding: "utf8",
     timeout: 10 * 6e4
@@ -23499,14 +23871,14 @@ ${detail}` : ""}`
   }
   return { ok: true, executablePath: after.executablePath, installed: true };
 }
-var import_node_child_process5, import_node_fs12, import_node_module4, import_node_path15, PLAYWRIGHT_BROWSER_PROBE;
+var import_node_child_process6, import_node_fs14, import_node_module4, import_node_path17, PLAYWRIGHT_BROWSER_PROBE;
 var init_playwright_provisioning = __esm({
   "cli/drivers/playwright-provisioning.ts"() {
     "use strict";
-    import_node_child_process5 = require("node:child_process");
-    import_node_fs12 = require("node:fs");
+    import_node_child_process6 = require("node:child_process");
+    import_node_fs14 = require("node:fs");
     import_node_module4 = require("node:module");
-    import_node_path15 = require("node:path");
+    import_node_path17 = require("node:path");
     PLAYWRIGHT_BROWSER_PROBE = `
 const { existsSync } = require('node:fs');
 const modulePath = process.env.SOOTSIM_PW_MODULE;
@@ -24182,6 +24554,30 @@ var init_open_url2 = __esm({
   }
 });
 
+// cli/run-rnx.ts
+function rethrowIfExit(error) {
+  if (error instanceof RnxExit) throw error;
+}
+function rnxExit(code) {
+  throw new RnxExit(code);
+}
+var import_node_async_hooks, RnxExit, sinks;
+var init_run_rnx = __esm({
+  "cli/run-rnx.ts"() {
+    "use strict";
+    import_node_async_hooks = require("node:async_hooks");
+    RnxExit = class extends Error {
+      code;
+      constructor(code) {
+        super(`rnx exited with code ${code}`);
+        this.name = "RnxExit";
+        this.code = code;
+      }
+    };
+    sinks = new import_node_async_hooks.AsyncLocalStorage();
+  }
+});
+
 // cli/commands/inspect/env.ts
 function isAgentEnv() {
   if (process.env.SOOTSIM_AGENT === "0") return false;
@@ -24285,7 +24681,7 @@ async function runRuntime(args, opts = {}) {
     default:
       console.error(`  unknown runtime subcommand: ${sub}`);
       printHelp();
-      process.exit(1);
+      rnxExit(1);
   }
 }
 function printHelp() {
@@ -24342,7 +24738,7 @@ async function runtimeInstall(args, opts) {
     return result;
   } catch (err) {
     console.error(`  ${describeError(err)}`);
-    process.exit(1);
+    rnxExit(1);
   }
 }
 async function activateVersion(version) {
@@ -24433,14 +24829,14 @@ async function runtimeUse(args) {
   const version = args[0];
   if (!version) {
     console.error(`  usage: rnx runtime use <version>`);
-    process.exit(1);
+    rnxExit(1);
   }
   const installed2 = sootsimRuntime.listInstalled();
   if (!installed2.includes(version)) {
     console.error(`  version ${version} is not installed`);
     console.error(`  installed: ${installed2.join(", ") || "(none)"}`);
     console.error(`  run \`rnx runtime install ${version}\` first`);
-    process.exit(1);
+    rnxExit(1);
   }
   await activateVersion(version);
 }
@@ -24448,7 +24844,7 @@ async function runtimeRemove(args) {
   const version = args[0];
   if (!version) {
     console.error(`  usage: rnx runtime remove <version>`);
-    process.exit(1);
+    rnxExit(1);
   }
   const active = readActiveRuntime();
   if (active === version) {
@@ -24456,11 +24852,11 @@ async function runtimeRemove(args) {
     console.error(
       `  switch with \`rnx runtime use <other>\` first, or install another version`
     );
-    process.exit(1);
+    rnxExit(1);
   }
   if (readLiveRuntimeVersions().includes(version)) {
     console.error(`  cannot remove runtime ${version} while a project is using it`);
-    process.exit(1);
+    rnxExit(1);
   }
   const dir = runtimeDir(version);
   if (!import_fs8.default.existsSync(dir)) {
@@ -24481,7 +24877,7 @@ async function runtimeWhich() {
 async function runtimeNotes(args) {
   if (args.length > 0) {
     console.error(`  usage: rnx runtime notes`);
-    process.exit(1);
+    rnxExit(1);
   }
   const { config } = await resolveSootSimAppConfig();
   const version = config?.runtimeVersion ?? readActiveRuntime();
@@ -24532,6 +24928,7 @@ var init_runtime = __esm({
     init_home_paths();
     init_runtime_delivery();
     init_app_config();
+    init_run_rnx();
     init_runtime_notes();
     init_ws_bridge();
   }
@@ -24656,21 +25053,21 @@ function assertExplicitBridgeLock(preferredPort, explicitPort, lock) {
 }
 async function ensureRuntimeForOpen() {
   const active = readActiveRuntime();
-  if (active && import_node_fs13.default.existsSync(runtimeDir(active))) return;
+  if (active && import_node_fs15.default.existsSync(runtimeDir(active))) return;
   console.error("  installing rnx engine runtime...");
   const { runRuntime: runRuntime2 } = await Promise.resolve().then(() => (init_runtime(), runtime_exports));
   await runRuntime2(["install"], {});
 }
 function spawnSootsim(args) {
   const entry = process.argv[1];
-  if (entry && import_node_fs13.default.existsSync(entry)) {
-    return (0, import_node_child_process6.spawn)(process.execPath, [entry, ...args], {
+  if (entry && import_node_fs15.default.existsSync(entry)) {
+    return (0, import_node_child_process7.spawn)(process.execPath, [entry, ...args], {
       detached: true,
       stdio: "ignore",
       env: process.env
     });
   }
-  return (0, import_node_child_process6.spawn)(rnxPublicBrand.commandName, args, {
+  return (0, import_node_child_process7.spawn)(rnxPublicBrand.commandName, args, {
     detached: true,
     stdio: "ignore",
     env: process.env
@@ -24751,7 +25148,7 @@ async function resolveConnectionInputForCli(target) {
   const registeredPort = /^\d+$/.test(normalized) ? Number(normalized) : localBasePort(normalized);
   if (registeredPort && registeredPort > 0) {
     const discovered = await probePort(registeredPort);
-    if (discovered) {
+    if (discovered && !discovered.bundleUrlProvisional) {
       return {
         bundleUrl: discovered.bundleUrl,
         port: discovered.port,
@@ -24810,10 +25207,10 @@ async function buildResolvedBundleOpenUrl(target, baseUrl, opts = {}) {
 }
 function normalizeReplacementPath(filePath) {
   if (filePath.startsWith("~/")) {
-    return import_node_path16.default.join(import_node_os3.default.homedir(), filePath.slice(2));
+    return import_node_path18.default.join(import_node_os3.default.homedir(), filePath.slice(2));
   }
-  if (import_node_path16.default.isAbsolute(filePath)) return filePath;
-  return import_node_path16.default.resolve(process.cwd(), filePath);
+  if (import_node_path18.default.isAbsolute(filePath)) return filePath;
+  return import_node_path18.default.resolve(process.cwd(), filePath);
 }
 function parseOpenRuntimeConfig(args) {
   const modules = {};
@@ -24823,18 +25220,18 @@ function parseOpenRuntimeConfig(args) {
       const raw = args[i + 1];
       if (!raw) {
         console.error("  rnx open: --replace expects <module>=<file>");
-        process.exit(1);
+        rnxExit(1);
       }
       const eqIndex = raw.indexOf("=");
       if (eqIndex <= 0 || eqIndex === raw.length - 1) {
         console.error("  rnx open: --replace expects <module>=<file>");
-        process.exit(1);
+        rnxExit(1);
       }
       const moduleName = raw.slice(0, eqIndex).trim();
       const filePath = normalizeReplacementPath(raw.slice(eqIndex + 1).trim());
-      if (!import_node_fs13.default.existsSync(filePath)) {
+      if (!import_node_fs15.default.existsSync(filePath)) {
         console.error(`  rnx open: replacement file not found: ${filePath}`);
-        process.exit(1);
+        rnxExit(1);
       }
       modules[moduleName] = { file: filePath };
       i++;
@@ -24845,7 +25242,7 @@ function parseOpenRuntimeConfig(args) {
       const eqIndex = raw ? raw.indexOf("=") : -1;
       if (!raw || eqIndex <= 0 || eqIndex === raw.length - 1) {
         console.error("  rnx open: --remap expects <host:port>=<host:port>");
-        process.exit(1);
+        rnxExit(1);
       }
       remap[raw.slice(0, eqIndex).trim()] = raw.slice(eqIndex + 1).trim();
       i++;
@@ -24863,7 +25260,7 @@ async function resolveOpenAppProject(resolvedBundle) {
   return advertisedRoot ? resolveAppProject(advertisedRoot) : null;
 }
 async function ensureConfiguredRuntime(version) {
-  if (import_node_fs13.default.existsSync(import_node_path16.default.join(runtimeDir(version), "index.html"))) return;
+  if (import_node_fs15.default.existsSync(import_node_path18.default.join(runtimeDir(version), "index.html"))) return;
   console.error(`  installing configured engine runtime ${version}...`);
   const result = await sootsimRuntime.install({
     version,
@@ -25223,7 +25620,7 @@ function playwrightHostPidForSim(sim) {
 function signalDriverLaunchConnected(result) {
   if (!result.connectAckFile) return false;
   try {
-    import_node_fs13.default.writeFileSync(
+    import_node_fs15.default.writeFileSync(
       result.connectAckFile,
       `${JSON.stringify({ connectedAt: Date.now(), pid: result.pid ?? null })}
 `,
@@ -25237,19 +25634,19 @@ function signalDriverLaunchConnected(result) {
 function printDriverDiagnosticLogTail(result) {
   if (!result.diagnosticLogPath) return;
   try {
-    const detail = import_node_fs13.default.readFileSync(result.diagnosticLogPath, "utf8").trim();
+    const detail = import_node_fs15.default.readFileSync(result.diagnosticLogPath, "utf8").trim();
     if (!detail) {
-      console.error(`  ${import_node_path16.default.basename(result.diagnosticLogPath)} was empty`);
+      console.error(`  ${import_node_path18.default.basename(result.diagnosticLogPath)} was empty`);
       return;
     }
     const shown = detail.length > 4e3 ? `\u2026
 ${detail.slice(-4e3)}` : detail;
-    console.error(`  ${import_node_path16.default.basename(result.diagnosticLogPath)}:`);
+    console.error(`  ${import_node_path18.default.basename(result.diagnosticLogPath)}:`);
     console.error(shown);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     console.error(
-      `  failed to read ${import_node_path16.default.basename(result.diagnosticLogPath)}: ${message}`
+      `  failed to read ${import_node_path18.default.basename(result.diagnosticLogPath)}: ${message}`
     );
   }
 }
@@ -25270,11 +25667,11 @@ async function waitForProcessExit(pid, timeoutMs = 2500) {
   return !isProcessAlive2(pid);
 }
 function isPlaywrightHostProcess(pid) {
-  const plain = (0, import_node_child_process6.spawnSync)("ps", ["-o", "command=", "-p", String(pid)], {
+  const plain = (0, import_node_child_process7.spawnSync)("ps", ["-o", "command=", "-p", String(pid)], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
-  const withEnv = (0, import_node_child_process6.spawnSync)("ps", ["eww", "-o", "command=", "-p", String(pid)], {
+  const withEnv = (0, import_node_child_process7.spawnSync)("ps", ["eww", "-o", "command=", "-p", String(pid)], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -25438,7 +25835,7 @@ async function runLinkCommand(args, opts = {}) {
   if (parsed.positional.length !== 1) {
     console.error("  rnx open: expected exactly one <url-or-route>");
     console.error("  examples: rnx open /settings  |  rnx open myapp://settings");
-    process.exit(1);
+    rnxExit(1);
   }
   const bridge = createBridgeFromParsed(parsed);
   const simHint = parsed.simId ? ` --sim ${parsed.simId}` : "";
@@ -25452,7 +25849,7 @@ async function runLinkCommand(args, opts = {}) {
       warningsCommand: `rnx get warnings 5${simHint}`,
       requestsCommand: `rnx get requests 5${simHint}`
     });
-    process.exit(1);
+    rnxExit(1);
   } finally {
     bridge.close();
   }
@@ -25490,11 +25887,11 @@ async function runOpenCommand(args, opts = {}) {
     console.error(
       `  rnx open: --cdp-port must be a positive port number, got "${cdpPortArg}"`
     );
-    process.exit(1);
+    rnxExit(1);
   }
   if (requestedProfileId && ephemeralProfile) {
     console.error("  rnx open: --profile cannot be combined with --ephemeral");
-    process.exit(1);
+    rnxExit(1);
   }
   const profileId = requestedProfileId ? ensureProfile(requestedProfileId).id : void 0;
   const openInNewSim = args.includes("--new") || !!profileId || ephemeralProfile;
@@ -25503,7 +25900,7 @@ async function runOpenCommand(args, opts = {}) {
     console.error(
       "  rnx open: --new, --profile, and --ephemeral cannot be combined with --sim"
     );
-    process.exit(1);
+    rnxExit(1);
   }
   const target = parsed.positional[0] || "";
   if (isAppDeepLinkTarget(target)) {
@@ -25511,7 +25908,7 @@ async function runOpenCommand(args, opts = {}) {
       console.error(
         "  rnx open: deep links target the current app; remove --new, --profile, or --ephemeral"
       );
-      process.exit(1);
+      rnxExit(1);
     }
     await runLinkCommand(args, opts);
     return;
@@ -25535,7 +25932,7 @@ async function runOpenCommand(args, opts = {}) {
         `  could not launch a browser: ${err instanceof Error ? err.message : String(err)}`
       );
       console.error(`  open it yourself: ${target}`);
-      process.exit(1);
+      rnxExit(1);
     }
     console.log(
       isLocal ? "  to drive it under the CLI, point `rnx open` at the app\u2019s dev port instead (e.g. `rnx open 8081`)." : "  the CLI can\u2019t drive a remote preview (the engine only attaches to the local bridge from localhost). to drive the app, run it locally and `rnx open <port>`."
@@ -25565,33 +25962,33 @@ async function runOpenCommand(args, opts = {}) {
   const requestedDriverId = args.find((_, i) => args[i - 1] === "--driver") || "";
   if (requestedDriverId && !isDriverId(requestedDriverId)) {
     console.error(`  unknown driver "${requestedDriverId}" \u2014 run \`rnx list --drivers\``);
-    process.exit(1);
+    rnxExit(1);
   }
   const driverId = isDriverId(requestedDriverId) ? requestedDriverId : process.env.CI === "1" || process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true" || isAgentEnv() || !process.stdin.isTTY ? "playwright" : readSimulatorDriverPreference() || "playwright";
   const driverHeadless = resolveDriverHeadless(args, driverId);
   if (cdpPort && driverId !== "playwright") {
     console.error("  rnx open: --cdp-port is only honored by the playwright driver");
-    process.exit(1);
+    rnxExit(1);
   }
   const hotFlag = args.includes("--hot");
   const noHmrFlag = args.includes("--no-hmr");
   if (hotFlag && noHmrFlag) {
     console.error("  rnx open: --hot and --no-hmr cannot be combined");
-    process.exit(1);
+    rnxExit(1);
   }
   const hotMode = hotFlag ? true : noHmrFlag ? false : driverId !== "playwright";
   const deviceArg = args.find((_, i) => args[i - 1] === "--device");
   if (deviceArg && !(deviceArg in import_settings.devices)) {
     console.error(`  rnx open: unknown device "${deviceArg}"`);
     console.error(`  known devices: ${(0, import_settings.listSelectableDeviceModels)().join(", ")}`);
-    process.exit(1);
+    rnxExit(1);
   }
   const deviceSpec = deviceArg ? import_settings.devices[deviceArg] : void 0;
   const viewportArg = args.find((_, i) => args[i - 1] === "--viewport");
   const viewportMatch = viewportArg ? /^(\d+)x(\d+)$/.exec(viewportArg) : null;
   if (viewportArg && !viewportMatch) {
     console.error(`  rnx open: --viewport must be <width>x<height>, got "${viewportArg}"`);
-    process.exit(1);
+    rnxExit(1);
   }
   const explicitViewport = viewportMatch ? { width: Number(viewportMatch[1]), height: Number(viewportMatch[2]) } : void 0;
   const buildShellUrlOpts = {
@@ -25684,7 +26081,7 @@ async function runOpenCommand(args, opts = {}) {
           warningsCommand: `rnx get warnings 5${simHint}`,
           requestsCommand: `rnx get requests 5${simHint}`
         });
-        process.exit(1);
+        rnxExit(1);
       }
       if (!fallBackToNewSim && targetSim) {
         await sleep2(1500);
@@ -25695,7 +26092,7 @@ async function runOpenCommand(args, opts = {}) {
         );
         if (!ready) {
           console.error("  timed out waiting for current sim to load target");
-          process.exit(1);
+          rnxExit(1);
         }
         ready.bridge.close();
         saveCurrentSimId(targetSim.id);
@@ -25721,13 +26118,13 @@ async function runOpenCommand(args, opts = {}) {
     console.error(
       "  could not resolve a stable owning process; refusing unsupervised sim host"
     );
-    process.exit(1);
+    rnxExit(1);
   }
   const simMatchesToken = (sim) => sim.url?.includes(`inspectOpen=${token}`) ?? false;
   const driver = getDriver(driverId);
   if (!driver) {
     console.error(`  unknown driver "${driverId}" \u2014 run \`rnx list --drivers\``);
-    process.exit(1);
+    rnxExit(1);
   }
   const connectWait = resolveDriverConnectWaitOptions();
   const result = await driver.launch({
@@ -25747,7 +26144,7 @@ async function runOpenCommand(args, opts = {}) {
   });
   if (!result.launched) {
     console.error(`  ${driver.name} driver: ${result.message}`);
-    process.exit(1);
+    rnxExit(1);
   }
   const outcome = await waitForSimMatchOrHostExit(
     parsed.wsPort,
@@ -25759,7 +26156,7 @@ async function runOpenCommand(args, opts = {}) {
   if (outcome.kind === "host-exit") {
     printDriverDiagnosticLogTail(result);
     console.error(`  ${driver.name} host crashed \u2014 sim is no longer attached`);
-    process.exit(1);
+    rnxExit(1);
   }
   if (outcome.kind === "timeout") {
     if (result.pid) {
@@ -25773,7 +26170,7 @@ async function runOpenCommand(args, opts = {}) {
     console.error(
       `  timed out after ${connectWait.timeoutMs}ms waiting for opened sim to connect`
     );
-    process.exit(1);
+    rnxExit(1);
   }
   const match = outcome.sim;
   saveCurrentSimId(match.id);
@@ -25802,7 +26199,7 @@ async function runUseLikeCommand(args, opts = {}) {
             `  refused: ${target.id} is locked by the active user (${secs}s) \u2014 that's a live human tab`
           );
           console.error(`  run \`rnx open --new\` for a fresh investigation sim`);
-          process.exit(1);
+          rnxExit(1);
         }
         if (!force) {
           console.error(
@@ -25811,20 +26208,21 @@ async function runUseLikeCommand(args, opts = {}) {
           console.error(
             `  \`sootsim use ${target.id} --force\` to take it, or \`rnx open --new\` for a fresh sim`
           );
-          process.exit(1);
+          rnxExit(1);
         }
       }
       await bridge.focusSim(target.id);
       saveCurrentSimId(target.id);
       console.log(`  using: ${target.id}`);
     } catch (err) {
+      rethrowIfExit(err);
       console.error(`  use failed: ${err instanceof Error ? err.message : String(err)}`);
       await printBridgeFailureDiagnostics(bridge, {
         errorsCommand: `rnx get errors 5${simHint}`,
         warningsCommand: `rnx get warnings 5${simHint}`,
         requestsCommand: `rnx get requests 5${simHint}`
       });
-      process.exit(1);
+      rnxExit(1);
     }
   } finally {
     bridge.close();
@@ -25862,10 +26260,10 @@ async function runClaimCommand(args, opts = {}) {
         const secs = Math.max(0, Math.round(err.lock.expiresInMs / 1e3));
         console.error(`  claim failed: locked by ${err.lock.by} for ${secs}s more`);
         console.error(`  use --force to take it, or \`rnx open --new\` for a fresh sim`);
-        process.exit(1);
+        rnxExit(1);
       }
       console.error(`  claim failed: ${err instanceof Error ? err.message : String(err)}`);
-      process.exit(1);
+      rnxExit(1);
     }
   } finally {
     bridge.close();
@@ -25972,7 +26370,7 @@ async function runCloseCommand(args, opts = {}) {
         console.error(
           `  close failed: keep sim ${plan.missingExplicitKeepId} is not connected; not closing other sims`
         );
-        process.exit(1);
+        rnxExit(1);
       }
       if (plan.targets.length === 0) {
         console.log(
@@ -25996,11 +26394,12 @@ async function runCloseCommand(args, opts = {}) {
       console.log(summary);
       if (result.remaining.length > 0) {
         console.error(`  close failed: still connected: ${result.remaining.join(", ")}`);
-        process.exit(1);
+        rnxExit(1);
       }
     } catch (err) {
+      rethrowIfExit(err);
       console.error(`  close failed: ${err instanceof Error ? err.message : String(err)}`);
-      process.exit(1);
+      rnxExit(1);
     } finally {
       bridge.close();
     }
@@ -26022,7 +26421,7 @@ async function runCloseCommand(args, opts = {}) {
       if (!closed) {
         await terminatePlaywrightHostsForSims(sims, [target.id]);
         console.error(`  close failed: ${target.id} is still connected`);
-        process.exit(1);
+        rnxExit(1);
       }
       await terminatePlaywrightHostsForSims(sims, [target.id]);
       if (readCurrentSimId() === target.id) {
@@ -26031,26 +26430,27 @@ async function runCloseCommand(args, opts = {}) {
       }
       console.log(`  closed: ${target.id}`);
     } catch (err) {
+      rethrowIfExit(err);
       console.error(`  close failed: ${err instanceof Error ? err.message : String(err)}`);
       await printBridgeFailureDiagnostics(bridge, {
         errorsCommand: `rnx get errors 5${simHint}`,
         warningsCommand: `rnx get warnings 5${simHint}`,
         requestsCommand: `rnx get requests 5${simHint}`
       });
-      process.exit(1);
+      rnxExit(1);
     }
   } finally {
     bridge.close();
   }
 }
-var import_node_child_process6, import_node_fs13, import_node_os3, import_node_path16, import_settings, import_ws5, DEFAULT_DRIVER_CONNECT_TIMEOUT_MS, DRIVER_CONNECT_INTERVAL_MS, DRIVER_CONNECT_HOST_GRACE_MS, OPEN_BRIDGE_SPAWN_TIMEOUT_MS, SHELL_APPS;
+var import_node_child_process7, import_node_fs15, import_node_os3, import_node_path18, import_settings, import_ws5, DEFAULT_DRIVER_CONNECT_TIMEOUT_MS, DRIVER_CONNECT_INTERVAL_MS, DRIVER_CONNECT_HOST_GRACE_MS, OPEN_BRIDGE_SPAWN_TIMEOUT_MS, SHELL_APPS;
 var init_control = __esm({
   "cli/commands/control.ts"() {
     "use strict";
-    import_node_child_process6 = require("node:child_process");
-    import_node_fs13 = __toESM(require("node:fs"), 1);
+    import_node_child_process7 = require("node:child_process");
+    import_node_fs15 = __toESM(require("node:fs"), 1);
     import_node_os3 = __toESM(require("node:os"), 1);
-    import_node_path16 = __toESM(require("node:path"), 1);
+    import_node_path18 = __toESM(require("node:path"), 1);
     import_settings = require("sootsim-engine/settings");
     import_ws5 = require("ws");
     init_dev_server_scanner();
@@ -26073,6 +26473,7 @@ var init_control = __esm({
     init_current_sim();
     init_registry2();
     init_open_url2();
+    init_run_rnx();
     init_ws_bridge();
     init_core();
     init_env();
@@ -26913,14 +27314,14 @@ process.stdin.on('end', async () => {
 function getBaseDir() {
   const explicit = process.env[SESSION_FILE_ENV];
   if (explicit?.trim()) {
-    return (0, import_node_path17.dirname)((0, import_node_path17.resolve)(explicit));
+    return (0, import_node_path19.dirname)((0, import_node_path19.resolve)(explicit));
   }
   return electronUserDataDir();
 }
 function getSharedDesktopAuthFilePath() {
   const explicit = process.env[SESSION_FILE_ENV];
-  if (explicit?.trim()) return (0, import_node_path17.resolve)(explicit);
-  return (0, import_node_path17.join)(getBaseDir(), "desktop-auth.json");
+  if (explicit?.trim()) return (0, import_node_path19.resolve)(explicit);
+  return (0, import_node_path19.join)(getBaseDir(), "desktop-auth.json");
 }
 function normalizeUser(input) {
   if (!input || typeof input !== "object") return null;
@@ -26967,26 +27368,26 @@ function normalizeSession(input) {
 }
 function readSharedDesktopAuthSession() {
   const filepath = getSharedDesktopAuthFilePath();
-  if (!(0, import_node_fs14.existsSync)(filepath)) return null;
+  if (!(0, import_node_fs16.existsSync)(filepath)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs14.readFileSync)(filepath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs16.readFileSync)(filepath, "utf8"));
     const normalized = normalizeSession(parsed);
     if (!normalized) {
-      (0, import_node_fs14.rmSync)(filepath, { force: true });
+      (0, import_node_fs16.rmSync)(filepath, { force: true });
       return null;
     }
     return normalized;
   } catch {
-    (0, import_node_fs14.rmSync)(filepath, { force: true });
+    (0, import_node_fs16.rmSync)(filepath, { force: true });
     return null;
   }
 }
-var import_node_fs14, import_node_path17, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
+var import_node_fs16, import_node_path19, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
 var init_shared_session = __esm({
   "src/auth/shared-session.ts"() {
     "use strict";
-    import_node_fs14 = require("node:fs");
-    import_node_path17 = require("node:path");
+    import_node_fs16 = require("node:fs");
+    import_node_path19 = require("node:path");
     init_home_paths();
     SESSION_VERSION = 1;
     SESSION_FILE_ENV = "SOOTSIM_SHARED_AUTH_FILE";
@@ -27057,6 +27458,7 @@ var init_auth = __esm({
   "cli/auth.ts"() {
     "use strict";
     init_shared_session();
+    init_run_rnx();
     GITHUB_TOKEN_PREFIXES = ["ghs_", "ghp_", "gho_", "ghu_", "github_pat_"];
   }
 });
@@ -27089,6 +27491,7 @@ var init_upload = __esm({
     init_auth();
     init_open_url2();
     init_run_registry();
+    init_run_rnx();
     init_ws_bridge();
     REMOTE_DEFAULT_ORIGIN = process.env.SOOTSIM_UPLOAD_ORIGIN || "https://contrast.dev";
     REMOTE_DEFAULT_PUBLIC_PREVIEW_ORIGIN = process.env.SOOTSIM_PREVIEW_ORIGIN || rnxPublicBrand.origin;
@@ -27120,7 +27523,7 @@ async function ensureCliRecordingEntitlement(commandLabel, opts = {}) {
 
 `
     );
-    process.exit(1);
+    rnxExit(1);
   }
   if (auth.kind === "github" && opts.allowGitHubAuth) return;
   const billingOrigin = await billingOriginFor(auth, opts.originOverride);
@@ -27137,7 +27540,7 @@ async function ensureCliRecordingEntitlement(commandLabel, opts = {}) {
 
 `
     );
-    process.exit(1);
+    rnxExit(1);
   }
   if (res.status === 401) {
     process.stderr.write(
@@ -27147,7 +27550,7 @@ async function ensureCliRecordingEntitlement(commandLabel, opts = {}) {
 
 `
     );
-    process.exit(1);
+    rnxExit(1);
   }
   if (!res.ok) {
     const text = await res.text().catch(() => "");
@@ -27158,7 +27561,7 @@ async function ensureCliRecordingEntitlement(commandLabel, opts = {}) {
 
 `
     );
-    process.exit(1);
+    rnxExit(1);
   }
   const data = await res.json();
   if (data.entitlements?.desktopRecording === true) return;
@@ -27171,7 +27574,7 @@ async function ensureCliRecordingEntitlement(commandLabel, opts = {}) {
 
 `
   );
-  process.exit(1);
+  rnxExit(1);
 }
 var init_recording_access = __esm({
   "cli/recording-access.ts"() {
@@ -27179,6 +27582,7 @@ var init_recording_access = __esm({
     init_shared_session();
     init_auth();
     init_upload();
+    init_run_rnx();
   }
 });
 
@@ -27225,16 +27629,16 @@ function resolveFlowScreenshotPath(screenshotDir, name2) {
 }
 function resolveProjectRelativeFlowBase(flowDir) {
   if (!flowDir) return process.cwd();
-  return path16.basename(flowDir) === ".maestro" ? path16.dirname(flowDir) : flowDir;
+  return path18.basename(flowDir) === ".maestro" ? path18.dirname(flowDir) : flowDir;
 }
 function resolveFlowScreenshotPathWithMode(screenshotDir, name2, opts) {
   const normalizedName = name2.endsWith(".png") ? name2 : `${name2}.png`;
-  if (path16.isAbsolute(normalizedName)) return normalizedName;
+  if (path18.isAbsolute(normalizedName)) return normalizedName;
   if (opts.mode === "flow" && /[\\/]/.test(normalizedName)) {
     const baseDir = normalizedName.startsWith("./") || normalizedName.startsWith("../") ? opts.flowDir ?? process.cwd() : resolveProjectRelativeFlowBase(opts.flowDir);
-    return path16.resolve(baseDir, normalizedName);
+    return path18.resolve(baseDir, normalizedName);
   }
-  return path16.join(screenshotDir, normalizedName);
+  return path18.join(screenshotDir, normalizedName);
 }
 function normalizeFlowScreenshotSpec(step) {
   if (typeof step === "string") {
@@ -27291,12 +27695,12 @@ function parseFlowSteps(content) {
   const parsed = import_yaml.default.parse(candidate);
   return Array.isArray(parsed) ? parsed : [];
 }
-var fs16, path16, import_settings3, import_yaml, import_proof_frame, DEFAULT_TIMEOUT, FLOW_TIMEOUT_SCALE, scaledTimeout, SCREEN_W, SCREEN_H, SootSimBridgeFlowRunner;
+var fs18, path18, import_settings3, import_yaml, import_proof_frame, DEFAULT_TIMEOUT, FLOW_TIMEOUT_SCALE, scaledTimeout, SCREEN_W, SCREEN_H, SootSimBridgeFlowRunner;
 var init_bridge_flow_runner = __esm({
   "cli/bridge-flow-runner.ts"() {
     "use strict";
-    fs16 = __toESM(require("fs"), 1);
-    path16 = __toESM(require("path"), 1);
+    fs18 = __toESM(require("fs"), 1);
+    path18 = __toESM(require("path"), 1);
     import_settings3 = require("sootsim-engine/settings");
     import_yaml = __toESM(require("yaml"), 1);
     import_proof_frame = __toESM(require_proof_frame(), 1);
@@ -27503,14 +27907,14 @@ var init_bridge_flow_runner = __esm({
         if (chunks.length === 0) {
           throw new Error("recording requested but no video buffer was produced");
         }
-        fs16.mkdirSync(this.opts.recordingOutputDir, { recursive: true });
+        fs18.mkdirSync(this.opts.recordingOutputDir, { recursive: true });
         const videoMime = stopped.mime || this.opts.recordingFormat || "video/webm";
         const extension = videoMime.includes("mp4") ? "mp4" : "webm";
-        const outputPath = path16.join(
+        const outputPath = path18.join(
           this.opts.recordingOutputDir,
           `sootsim-${Date.now()}.${extension}`
         );
-        fs16.writeFileSync(outputPath, Buffer.concat(chunks));
+        fs18.writeFileSync(outputPath, Buffer.concat(chunks));
         return outputPath;
       }
       async waitForRecordingTail(opts) {
@@ -28006,7 +28410,7 @@ var init_bridge_flow_runner = __esm({
             flowDir: this.opts.flowDir
           }
         );
-        fs16.mkdirSync(path16.dirname(outputPath), { recursive: true });
+        fs18.mkdirSync(path18.dirname(outputPath), { recursive: true });
         const layers = spec.layers ?? this.opts.screenshotLayers;
         const screenshotRequest = {
           type: "screenshot",
@@ -28045,11 +28449,11 @@ var init_bridge_flow_runner = __esm({
             throw new Error("could not read current device model for framed screenshot");
           }
           const framed = await composeFramedScreenshot(rawBuffer, model);
-          fs16.writeFileSync(outputPath, framed);
+          fs18.writeFileSync(outputPath, framed);
           console.log(`[flow] screenshot: ${outputPath} (frame: ${model})`);
           return outputPath;
         }
-        fs16.writeFileSync(outputPath, rawBuffer);
+        fs18.writeFileSync(outputPath, rawBuffer);
         console.log(`[flow] screenshot: ${outputPath}`);
         return outputPath;
       }
@@ -28071,10 +28475,10 @@ var init_bridge_flow_runner = __esm({
       // + a11y tree + console errors/warnings + failed network requests +
       // shell state, all under one directory so post-mortem is one grep away.
       async captureFailureBundle(outputDir, context) {
-        fs16.mkdirSync(outputDir, { recursive: true });
+        fs18.mkdirSync(outputDir, { recursive: true });
         const write = (name2, content) => {
           try {
-            fs16.writeFileSync(path16.join(outputDir, name2), content);
+            fs18.writeFileSync(path18.join(outputDir, name2), content);
           } catch {
           }
         };
@@ -28612,8 +29016,8 @@ var init_bridge_flow_runner = __esm({
       runScript(target) {
         const spec = typeof target === "string" ? { file: target } : target;
         if (!spec.file) throw new Error("runScript requires a file");
-        const scriptPath = path16.resolve(this.opts.flowDir, spec.file);
-        const source = fs16.readFileSync(scriptPath, "utf8");
+        const scriptPath = path18.resolve(this.opts.flowDir, spec.file);
+        const source = fs18.readFileSync(scriptPath, "utf8");
         this.js.evaluate(source, { env: spec.env });
         console.log(`[flow]   runScript: ${spec.file} done`);
       }
@@ -28910,10 +29314,10 @@ var init_bridge_flow_runner = __esm({
               for (const [k, v] of Object.entries(env)) this.js.putEnv(k, v);
             }
             if (file) {
-              const flowPath = path16.resolve(this.opts.flowDir, file);
-              const flowContent = fs16.readFileSync(flowPath, "utf8");
+              const flowPath = path18.resolve(this.opts.flowDir, file);
+              const flowContent = fs18.readFileSync(flowPath, "utf8");
               const previousDir = this.opts.flowDir;
-              this.opts.flowDir = path16.dirname(flowPath);
+              this.opts.flowDir = path18.dirname(flowPath);
               try {
                 await this.runFlow(parseFlowSteps(flowContent));
               } finally {
@@ -29068,8 +29472,8 @@ __export(registry_exports, {
   skillRegistry: () => skillRegistry
 });
 module.exports = __toCommonJS(registry_exports);
-var fs17 = __toESM(require("fs"), 1);
-var path17 = __toESM(require("path"), 1);
+var fs19 = __toESM(require("fs"), 1);
+var path19 = __toESM(require("path"), 1);
 
 // src/skills/builtin/a11y-review.ts
 init_reap_browser();
@@ -29088,8 +29492,8 @@ var skill = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path18 = await import("path");
-        const fs18 = await import("fs");
+        const path20 = await import("path");
+        const fs20 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -29144,9 +29548,9 @@ var skill = {
             warnings: issues.filter((i) => i.severity === "warning").length,
             tree: typeof tree === "string" ? tree : JSON.stringify(tree)
           };
-          const reportPath = path18.join(context.outputDir, "a11y-report.json");
-          fs18.mkdirSync(path18.dirname(reportPath), { recursive: true });
-          fs18.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+          const reportPath = path20.join(context.outputDir, "a11y-report.json");
+          fs20.mkdirSync(path20.dirname(reportPath), { recursive: true });
+          fs20.writeFileSync(reportPath, JSON.stringify(report, null, 2));
           return {
             success: issues.filter((i) => i.severity === "error").length === 0,
             message: `${report.errors} errors, ${report.warnings} warnings across ${report.nodeCount} nodes`,
@@ -29179,14 +29583,14 @@ var skill2 = {
         }
       },
       async execute(params, context) {
-        const fs18 = await import("node:fs");
-        const path18 = await import("node:path");
+        const fs20 = await import("node:fs");
+        const path20 = await import("node:path");
         const { COMPAT_RESULT_CAVEAT: COMPAT_RESULT_CAVEAT2, formatPackageStatus: formatPackageStatus2, formatScanCounts: formatScanCounts2, scanDeps: scanDeps2 } = await Promise.resolve().then(() => (init_web(), web_exports));
-        const packagePath = path18.join(context.projectDir, "package.json");
-        if (!fs18.existsSync(packagePath)) {
+        const packagePath = path20.join(context.projectDir, "package.json");
+        if (!fs20.existsSync(packagePath)) {
           return { success: false, message: "No package.json found" };
         }
-        const parsed = JSON.parse(fs18.readFileSync(packagePath, "utf8"));
+        const parsed = JSON.parse(fs20.readFileSync(packagePath, "utf8"));
         if (!parsed || typeof parsed !== "object") {
           return { success: false, message: "package.json is not an object" };
         }
@@ -29198,9 +29602,9 @@ var skill2 = {
         }) : scanDeps2(parsed);
         const packageResult = params.packageName ? scan.packages[0] : void 0;
         const message = packageResult ? `${params.packageName}: ${formatPackageStatus2(packageResult)}. ${COMPAT_RESULT_CAVEAT2}` : `${formatScanCounts2(scan)}. ${COMPAT_RESULT_CAVEAT2}`;
-        const reportPath = path18.join(context.outputDir, "compat-report.json");
-        fs18.mkdirSync(path18.dirname(reportPath), { recursive: true });
-        fs18.writeFileSync(reportPath, `${JSON.stringify(scan, null, 2)}
+        const reportPath = path20.join(context.outputDir, "compat-report.json");
+        fs20.mkdirSync(path20.dirname(reportPath), { recursive: true });
+        fs20.writeFileSync(reportPath, `${JSON.stringify(scan, null, 2)}
 `);
         return {
           success: true,
@@ -29244,8 +29648,8 @@ var skill3 = {
         record: { type: "boolean", description: "Record video of the flow" }
       },
       async execute(params, context) {
-        const fs18 = await import("fs");
-        const path18 = await import("path");
+        const fs20 = await import("fs");
+        const path20 = await import("path");
         const yaml2 = await import("yaml");
         const { DEFAULT_SOOTSIM_BRIDGE_PORT: DEFAULT_SOOTSIM_BRIDGE_PORT2 } = await Promise.resolve().then(() => (init_bridge_constants(), bridge_constants_exports));
         const { SootSimBridgeHost: SootSimBridgeHost2 } = await Promise.resolve().then(() => (init_bridge_host(), bridge_host_exports));
@@ -29255,7 +29659,7 @@ var skill3 = {
         const host = new SootSimBridgeHost2({ port: DEFAULT_SOOTSIM_BRIDGE_PORT2 });
         host.start({ silent: true });
         try {
-          const flowContent = fs18.readFileSync(params.flowPath, "utf8");
+          const flowContent = fs20.readFileSync(params.flowPath, "utf8");
           const fmMatch = flowContent.match(/^---\n([\s\S]*?)\n---\n?/);
           const stepsBody = fmMatch ? flowContent.slice(fmMatch[0].length) : flowContent;
           const steps = yaml2.parse(stepsBody);
@@ -29282,7 +29686,7 @@ var skill3 = {
           });
           const driver = new SootSimBridgeFlowRunner2(bridge, {
             screenshotDir: context.outputDir,
-            flowDir: path18.dirname(path18.resolve(params.flowPath)),
+            flowDir: path20.dirname(path20.resolve(params.flowPath)),
             simId,
             recordingOutputDir: params.record ? context.outputDir : void 0
           });
@@ -29304,7 +29708,7 @@ var skill3 = {
                 simId,
                 videoPath: videoPath || void 0
               },
-              artifacts: videoPath ? [{ type: "video", name: path18.basename(videoPath), path: videoPath }] : void 0
+              artifacts: videoPath ? [{ type: "video", name: path20.basename(videoPath), path: videoPath }] : void 0
             };
           } finally {
             try {
@@ -29351,8 +29755,8 @@ var skill4 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path18 = await import("path");
-        const fs18 = await import("fs");
+        const path20 = await import("path");
+        const fs20 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -29378,9 +29782,9 @@ var skill4 = {
             ...profile,
             fps: syncCount > 0 ? (syncCount / (duration / 1e3)).toFixed(1) : "0"
           };
-          const reportPath = path18.join(context.outputDir, "perf-report.json");
-          fs18.mkdirSync(path18.dirname(reportPath), { recursive: true });
-          fs18.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+          const reportPath = path20.join(context.outputDir, "perf-report.json");
+          fs20.mkdirSync(path20.dirname(reportPath), { recursive: true });
+          fs20.writeFileSync(reportPath, JSON.stringify(report, null, 2));
           return {
             success: true,
             message: `${report.fps} fps, ${profile.avgSyncMs?.toFixed(1)}ms avg sync, ${nodeCount} nodes`,
@@ -29413,8 +29817,8 @@ var skill5 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path18 = await import("path");
-        const fs18 = await import("fs");
+        const path20 = await import("path");
+        const fs20 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -29422,8 +29826,8 @@ var skill5 = {
         try {
           await page.goto(context.url, { waitUntil: "networkidle" });
           await page.waitForTimeout(2e3);
-          const outputPath = path18.join(context.outputDir, `${params.name}.png`);
-          fs18.mkdirSync(path18.dirname(outputPath), { recursive: true });
+          const outputPath = path20.join(context.outputDir, `${params.name}.png`);
+          fs20.mkdirSync(path20.dirname(outputPath), { recursive: true });
           await page.screenshot({ path: outputPath });
           return {
             success: true,
@@ -29464,8 +29868,8 @@ var skill6 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path18 = await import("path");
-        const fs18 = await import("fs");
+        const path20 = await import("path");
+        const fs20 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -29473,14 +29877,14 @@ var skill6 = {
         try {
           await page.goto(context.url, { waitUntil: "networkidle" });
           await page.waitForTimeout(2e3);
-          const currentPath = path18.join(context.outputDir, `${params.name}-current.png`);
-          fs18.mkdirSync(path18.dirname(currentPath), { recursive: true });
+          const currentPath = path20.join(context.outputDir, `${params.name}-current.png`);
+          fs20.mkdirSync(path20.dirname(currentPath), { recursive: true });
           await page.screenshot({ path: currentPath });
           try {
             const { PNG } = await import("pngjs");
             const pixelmatch = (await import("pixelmatch")).default;
-            const baseline = PNG.sync.read(fs18.readFileSync(params.baseline));
-            const current = PNG.sync.read(fs18.readFileSync(currentPath));
+            const baseline = PNG.sync.read(fs20.readFileSync(params.baseline));
+            const current = PNG.sync.read(fs20.readFileSync(currentPath));
             const { width, height } = baseline;
             const diff = new PNG({ width, height });
             const numDiffPixels = pixelmatch(
@@ -29491,8 +29895,8 @@ var skill6 = {
               height,
               { threshold: params.threshold || 0.1 }
             );
-            const diffPath = path18.join(context.outputDir, `${params.name}-diff.png`);
-            fs18.writeFileSync(diffPath, PNG.sync.write(diff));
+            const diffPath = path20.join(context.outputDir, `${params.name}-diff.png`);
+            fs20.writeFileSync(diffPath, PNG.sync.write(diff));
             const totalPixels = width * height;
             const diffPercent = (numDiffPixels / totalPixels * 100).toFixed(2);
             return {
@@ -29556,10 +29960,10 @@ var skillRegistry = {
   },
   // load skills from a project manifest (sootsim-skills.json)
   async loadFromManifest(projectDir) {
-    const manifestPath = path17.join(projectDir, "sootsim-skills.json");
-    if (!fs17.existsSync(manifestPath)) return;
+    const manifestPath = path19.join(projectDir, "sootsim-skills.json");
+    if (!fs19.existsSync(manifestPath)) return;
     try {
-      const manifest = JSON.parse(fs17.readFileSync(manifestPath, "utf8"));
+      const manifest = JSON.parse(fs19.readFileSync(manifestPath, "utf8"));
       if (Array.isArray(manifest.skills)) {
         for (const entry of manifest.skills) {
           if (typeof entry === "string") {
@@ -29570,7 +29974,7 @@ var skillRegistry = {
             }
           } else if (entry.file) {
             try {
-              const mod = await import(path17.resolve(projectDir, entry.file));
+              const mod = await import(path19.resolve(projectDir, entry.file));
               if (mod.skill) this.register(mod.skill);
             } catch {
             }
@@ -29583,10 +29987,10 @@ var skillRegistry = {
   // auto-discover skills based on project dependencies
   suggestSkills(projectDir) {
     const suggestions = [];
-    const pkgPath = path17.join(projectDir, "package.json");
-    if (!fs17.existsSync(pkgPath)) return suggestions;
+    const pkgPath = path19.join(projectDir, "package.json");
+    if (!fs19.existsSync(pkgPath)) return suggestions;
     try {
-      const pkg = JSON.parse(fs17.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs19.readFileSync(pkgPath, "utf8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps["detox"] || deps["maestro"]) {
         suggestions.push("maestro-test");