rnxsim 0.1.375 → 0.1.376

package/dist-lib/skills.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.375 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.376 | (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;
@@ -1688,14 +1688,6 @@ var init_unsupported_packages = __esm({
       "react-native-in-app-purchase": {
         note: "store billing runs entirely in StoreKit and Play Billing, which have no browser equivalent",
         recovery: "Use react-native-purchases for a full sandbox catalog, or react-native-iap if you only need the connection lifecycle."
-      },
-      // not a package refusal at all — a routing framework refusal. expo-router
-      // owns the entry point, the bundler config, the navigation tree and the app
-      // shell, so it is not something a seam can back. a Contrast app is already
-      // routed by One, which has the same file-based semantics.
-      "expo-router": {
-        note: "it is a whole routing framework that owns the app entry point, the bundler config and the navigation tree, so no native seam can back it",
-        recovery: "Contrast apps route with One, which has the same file-based routing: put screens in app/, and use Link, Stack, Tabs and useRouter from one."
       }
     };
     UNSUPPORTABLE = new Set(Object.keys(UNSUPPORTED_NATIVE_PACKAGES));
@@ -15211,9 +15203,22 @@ function makeResult(hostname, port, framework, owner) {
   };
 }
 function withRuntimeConfig(port, bundleUrl, projectCwd) {
-  const knownApp = projectCwd ? optionalDemoAppsSync().find(
-    (app) => app.preferredPort === port && (0, import_node_path3.resolve)(app.dir) === (0, import_node_path3.resolve)(projectCwd)
-  ) : void 0;
+  let physicalProjectCwd;
+  if (projectCwd) {
+    try {
+      physicalProjectCwd = (0, import_node_fs2.realpathSync)((0, import_node_path3.resolve)(projectCwd));
+    } catch {
+    }
+  }
+  const knownApps = physicalProjectCwd ? optionalDemoAppsSync().filter((app) => {
+    try {
+      return (0, import_node_fs2.realpathSync)((0, import_node_path3.resolve)(app.dir)) === physicalProjectCwd;
+    } catch {
+      return false;
+    }
+  }) : [];
+  const exactKnownApps = knownApps.filter((app) => app.preferredPort === port);
+  const knownApp = exactKnownApps.length === 1 ? exactKnownApps[0] : exactKnownApps.length === 0 && knownApps.length === 1 ? knownApps[0] : void 0;
   const configured = knownApp?.runtimeConfig ? applySootSimConfigToUrl(bundleUrl, knownApp.runtimeConfig) : bundleUrl;
   return normalizeNativeDevBundleUrl(configured);
 }
@@ -15533,7 +15538,7 @@ async function scanDevServers(opts = {}) {
   }
   return results.filter((r) => !isSootSimSelfServer(r));
 }
-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 import_child_process, import_promises2, import_http, import_net, import_node_fs2, 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";
@@ -15541,6 +15546,7 @@ var init_dev_server_scanner = __esm({
     import_promises2 = require("fs/promises");
     import_http = __toESM(require("http"), 1);
     import_net = __toESM(require("net"), 1);
+    import_node_fs2 = require("node:fs");
     import_node_path3 = require("node:path");
     init_backend_origin();
     init_config();
@@ -15610,7 +15616,7 @@ function getCliVersion() {
   ];
   for (const resolve7 of candidates) {
     try {
-      const version = JSON.parse((0, import_node_fs2.readFileSync)(resolve7(), "utf8")).version;
+      const version = JSON.parse((0, import_node_fs3.readFileSync)(resolve7(), "utf8")).version;
       if (typeof version === "string" && version) {
         cached2 = version;
         return cached2;
@@ -15621,11 +15627,11 @@ function getCliVersion() {
   cached2 = "0.0.0";
   return cached2;
 }
-var import_node_fs2, import_node_url2, import_meta, cached2;
+var import_node_fs3, import_node_url2, import_meta, cached2;
 var init_cli_version = __esm({
   "src/cli-version.ts"() {
     "use strict";
-    import_node_fs2 = require("node:fs");
+    import_node_fs3 = require("node:fs");
     import_node_url2 = require("node:url");
     init_public_brand();
     import_meta = {};
@@ -15701,7 +15707,7 @@ function isSootsimDevCheckout() {
   const argv1 = process.argv[1];
   if (!argv1) return false;
   try {
-    const real = import_node_fs3.default.realpathSync(argv1);
+    const real = import_node_fs4.default.realpathSync(argv1);
     return real.includes(`${import_node_path4.default.sep}packages${import_node_path4.default.sep}sootsim${import_node_path4.default.sep}`);
   } catch {
     return false;
@@ -15767,7 +15773,7 @@ function configFilePath() {
 }
 function readSharedConfig() {
   try {
-    const raw = import_node_fs3.default.readFileSync(configFilePath(), "utf8");
+    const raw = import_node_fs4.default.readFileSync(configFilePath(), "utf8");
     const parsed = JSON.parse(raw);
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
@@ -15785,9 +15791,9 @@ function writeSharedConfig(patch) {
     };
   }
   const tmp = `${configFilePath()}.tmp`;
-  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}
+  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}
 `, "utf8");
-  import_node_fs3.default.renameSync(tmp, configFilePath());
+  import_node_fs4.default.renameSync(tmp, configFilePath());
   return next;
 }
 function isOnboardingComplete() {
@@ -15834,14 +15840,14 @@ function runtimeUpgradeNoticePath() {
 function writeRuntimeUpgradeNotice(notice) {
   ensureSootsimHome();
   const tmp = `${runtimeUpgradeNoticePath()}.tmp`;
-  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(notice)}
+  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(notice)}
 `, "utf8");
-  import_node_fs3.default.renameSync(tmp, runtimeUpgradeNoticePath());
+  import_node_fs4.default.renameSync(tmp, runtimeUpgradeNoticePath());
 }
 function consumeRuntimeUpgradeNotice() {
   try {
-    const raw = import_node_fs3.default.readFileSync(runtimeUpgradeNoticePath(), "utf8");
-    import_node_fs3.default.unlinkSync(runtimeUpgradeNoticePath());
+    const raw = import_node_fs4.default.readFileSync(runtimeUpgradeNoticePath(), "utf8");
+    import_node_fs4.default.unlinkSync(runtimeUpgradeNoticePath());
     const parsed = JSON.parse(raw);
     if (typeof parsed?.to !== "string" || !parsed.to) return null;
     return {
@@ -15854,23 +15860,23 @@ function consumeRuntimeUpgradeNotice() {
   }
 }
 function ensureSootsimHome() {
-  import_node_fs3.default.mkdirSync(sootsimHomeDir(), { recursive: true });
-  import_node_fs3.default.mkdirSync(runtimesDir(), { recursive: true });
-  import_node_fs3.default.mkdirSync(electronDir(), { recursive: true });
-  import_node_fs3.default.mkdirSync(profilesDir(), { recursive: true });
-  import_node_fs3.default.mkdirSync(cacheDir(), { recursive: true });
+  import_node_fs4.default.mkdirSync(sootsimHomeDir(), { recursive: true });
+  import_node_fs4.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_node_fs4.default.mkdirSync(electronDir(), { recursive: true });
+  import_node_fs4.default.mkdirSync(profilesDir(), { recursive: true });
+  import_node_fs4.default.mkdirSync(cacheDir(), { recursive: true });
 }
 function readActiveRuntime() {
   try {
-    const value = import_node_fs3.default.readFileSync(activeRuntimeFile(), "utf8").trim();
+    const value = import_node_fs4.default.readFileSync(activeRuntimeFile(), "utf8").trim();
     return value.length > 0 ? value : null;
   } catch {
     return null;
   }
 }
 function writeActiveRuntime(version) {
-  import_node_fs3.default.mkdirSync(runtimesDir(), { recursive: true });
-  import_node_fs3.default.writeFileSync(activeRuntimeFile(), `${version}
+  import_node_fs4.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_node_fs4.default.writeFileSync(activeRuntimeFile(), `${version}
 `, "utf8");
 }
 function activeRuntimeDir() {
@@ -15878,17 +15884,17 @@ function activeRuntimeDir() {
   if (!version) return null;
   const dir = runtimeDir(version);
   try {
-    if (import_node_fs3.default.statSync(dir).isDirectory()) return dir;
+    if (import_node_fs4.default.statSync(dir).isDirectory()) return dir;
   } catch {
   }
   return null;
 }
 function readDaemonLockfile() {
   try {
-    const fd = import_node_fs3.default.openSync(daemonLockfilePath(), "r");
+    const fd = import_node_fs4.default.openSync(daemonLockfilePath(), "r");
     try {
       const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES);
-      const bytesRead = import_node_fs3.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
+      const bytesRead = import_node_fs4.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
       const raw = buf.subarray(0, bytesRead).toString("utf8");
       const parsed = JSON.parse(raw);
       if (parsed && parsed.schema === 1 && typeof parsed.pid === "number" && typeof parsed.bridgePort === "number" && typeof parsed.runtimePort === "number" && typeof parsed.startedAt === "number" && typeof parsed.heartbeatAt === "number" && (parsed.servedRuntimes === void 0 || Array.isArray(parsed.servedRuntimes) && parsed.servedRuntimes.every((version) => typeof version === "string"))) {
@@ -15896,7 +15902,7 @@ function readDaemonLockfile() {
       }
       return null;
     } finally {
-      import_node_fs3.default.closeSync(fd);
+      import_node_fs4.default.closeSync(fd);
     }
   } catch {
     return null;
@@ -15916,7 +15922,7 @@ function parseDevBridgeLockfile(raw) {
 function readDevBridgeLockfiles() {
   let entries;
   try {
-    entries = import_node_fs3.default.readdirSync(devBridgesDir(), { withFileTypes: true });
+    entries = import_node_fs4.default.readdirSync(devBridgesDir(), { withFileTypes: true });
   } catch {
     return [];
   }
@@ -15925,10 +15931,10 @@ function readDevBridgeLockfiles() {
     if (!entry.isFile() || !/^\d+\.json$/.test(entry.name)) continue;
     try {
       const filePath = import_node_path4.default.join(devBridgesDir(), entry.name);
-      const fd = import_node_fs3.default.openSync(filePath, "r");
+      const fd = import_node_fs4.default.openSync(filePath, "r");
       try {
         const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES);
-        const bytesRead = import_node_fs3.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
+        const bytesRead = import_node_fs4.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
         const lockfile = parseDevBridgeLockfile(
           buf.subarray(0, bytesRead).toString("utf8")
         );
@@ -15936,7 +15942,7 @@ function readDevBridgeLockfiles() {
           lockfiles.push(lockfile);
         }
       } finally {
-        import_node_fs3.default.closeSync(fd);
+        import_node_fs4.default.closeSync(fd);
       }
     } catch {
     }
@@ -15988,28 +15994,28 @@ function writeDaemonLockfile(data) {
     throw new Error("refusing to overwrite another rnx daemon lockfile");
   }
   const tmp = `${lockfilePath}.${data.pid}.${(0, import_node_crypto.randomUUID)()}.tmp`;
-  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
     const current = readDaemonLockfile();
     if (!current || !sameDaemonOwner(current, data)) {
       throw new Error("rnx daemon lock ownership changed during heartbeat");
     }
-    import_node_fs3.default.renameSync(tmp, lockfilePath);
+    import_node_fs4.default.renameSync(tmp, lockfilePath);
   } finally {
     try {
-      import_node_fs3.default.unlinkSync(tmp);
+      import_node_fs4.default.unlinkSync(tmp);
     } catch {
     }
   }
 }
 function writeDevBridgeLockfile(data) {
-  import_node_fs3.default.mkdirSync(devBridgesDir(), { recursive: true });
+  import_node_fs4.default.mkdirSync(devBridgesDir(), { recursive: true });
   const lockfilePath = devBridgeLockfilePath(data.bridgePort);
   const tmp = `${lockfilePath}.${data.pid}.tmp`;
-  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
 `, "utf8");
-  import_node_fs3.default.renameSync(tmp, lockfilePath);
+  import_node_fs4.default.renameSync(tmp, lockfilePath);
 }
 function sameDaemonOwner(left, right) {
   return left.pid === right.pid && left.startedAt === right.startedAt;
@@ -16020,17 +16026,17 @@ function isAlreadyExists(error) {
 function createDaemonLockfileExclusive(data) {
   const lockfilePath = daemonLockfilePath();
   const tmp = `${lockfilePath}.${data.pid}.${(0, import_node_crypto.randomUUID)()}.claim`;
-  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
-    import_node_fs3.default.linkSync(tmp, lockfilePath);
+    import_node_fs4.default.linkSync(tmp, lockfilePath);
     return true;
   } catch (error) {
     if (isAlreadyExists(error)) return false;
     throw error;
   } finally {
     try {
-      import_node_fs3.default.unlinkSync(tmp);
+      import_node_fs4.default.unlinkSync(tmp);
     } catch {
     }
   }
@@ -16054,7 +16060,7 @@ function parseDaemonClaim(raw) {
 }
 function readDaemonClaim() {
   try {
-    return parseDaemonClaim(import_node_fs3.default.readFileSync(daemonClaimPath(), "utf8"));
+    return parseDaemonClaim(import_node_fs4.default.readFileSync(daemonClaimPath(), "utf8"));
   } catch {
     return null;
   }
@@ -16078,7 +16084,7 @@ function acquireDaemonClaim(data) {
 `;
   for (let attempt = 0; attempt < 8; attempt++) {
     try {
-      import_node_fs3.default.writeFileSync(daemonClaimPath(), serialized, { encoding: "utf8", flag: "wx" });
+      import_node_fs4.default.writeFileSync(daemonClaimPath(), serialized, { encoding: "utf8", flag: "wx" });
       return true;
     } catch (error) {
       if (!isAlreadyExists(error)) throw error;
@@ -16088,11 +16094,11 @@ function acquireDaemonClaim(data) {
     if (existing && isDaemonClaimFresh(existing)) return false;
     let before;
     try {
-      before = import_node_fs3.default.readFileSync(daemonClaimPath(), "utf8");
+      before = import_node_fs4.default.readFileSync(daemonClaimPath(), "utf8");
       const latest = parseDaemonClaim(before);
       if (latest && isDaemonClaimFresh(latest)) return false;
-      if (import_node_fs3.default.readFileSync(daemonClaimPath(), "utf8") !== before) continue;
-      import_node_fs3.default.unlinkSync(daemonClaimPath());
+      if (import_node_fs4.default.readFileSync(daemonClaimPath(), "utf8") !== before) continue;
+      import_node_fs4.default.unlinkSync(daemonClaimPath());
     } catch {
     }
   }
@@ -16102,7 +16108,7 @@ function releaseDaemonClaim(owner) {
   try {
     const claim = readDaemonClaim();
     if (!claim || !sameDaemonOwner(claim, owner)) return;
-    import_node_fs3.default.unlinkSync(daemonClaimPath());
+    import_node_fs4.default.unlinkSync(daemonClaimPath());
   } catch {
   }
 }
@@ -16121,7 +16127,7 @@ function claimDaemonLockfile(data) {
       if (!latest || !sameDaemonOwner(latest, existing)) return false;
       if (isDaemonLockfileFresh(latest)) return false;
       try {
-        import_node_fs3.default.unlinkSync(daemonLockfilePath());
+        import_node_fs4.default.unlinkSync(daemonLockfilePath());
       } catch {
         return false;
       }
@@ -16135,25 +16141,25 @@ function removeDaemonLockfile(owner) {
   try {
     const lockfile = readDaemonLockfile();
     if (!lockfile || !sameDaemonOwner(lockfile, owner)) return;
-    import_node_fs3.default.unlinkSync(daemonLockfilePath());
+    import_node_fs4.default.unlinkSync(daemonLockfilePath());
   } catch {
   }
 }
 function removeDevBridgeLockfile(owner) {
   try {
     const lockfilePath = devBridgeLockfilePath(owner.bridgePort);
-    const lockfile = parseDevBridgeLockfile(import_node_fs3.default.readFileSync(lockfilePath, "utf8"));
+    const lockfile = parseDevBridgeLockfile(import_node_fs4.default.readFileSync(lockfilePath, "utf8"));
     if (lockfile?.pid !== owner.pid || lockfile.startedAt !== owner.startedAt) return;
-    import_node_fs3.default.unlinkSync(lockfilePath);
+    import_node_fs4.default.unlinkSync(lockfilePath);
   } catch {
   }
 }
-var import_node_crypto, import_node_fs3, import_node_os, import_node_path4, SOOTSIM_HOME_ENV, ACTIVE_RUNTIME_FILE, DAEMON_LOCKFILE, DEV_BRIDGES_DIR, CONFIG_FILE, DAEMON_HEARTBEAT_STALE_MS, CURRENT_ONBOARDING_VERSION, DAEMON_LOCKFILE_MAX_BYTES, DAEMON_CLAIM_STALE_MS;
+var import_node_crypto, import_node_fs4, import_node_os, import_node_path4, SOOTSIM_HOME_ENV, ACTIVE_RUNTIME_FILE, DAEMON_LOCKFILE, DEV_BRIDGES_DIR, CONFIG_FILE, DAEMON_HEARTBEAT_STALE_MS, CURRENT_ONBOARDING_VERSION, DAEMON_LOCKFILE_MAX_BYTES, DAEMON_CLAIM_STALE_MS;
 var init_home_paths = __esm({
   "src/home-paths.ts"() {
     "use strict";
     import_node_crypto = require("node:crypto");
-    import_node_fs3 = __toESM(require("node:fs"), 1);
+    import_node_fs4 = __toESM(require("node:fs"), 1);
     import_node_os = require("node:os");
     import_node_path4 = __toESM(require("node:path"), 1);
     SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
@@ -16174,7 +16180,7 @@ function isValidRuntimeVersion(value) {
 }
 function listInstalledRuntimes(product) {
   try {
-    return import_node_fs4.default.readdirSync(product.runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
+    return import_node_fs5.default.readdirSync(product.runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
   } catch {
     return [];
   }
@@ -16203,11 +16209,11 @@ function compareSemver(a, b) {
   if (!bp) return -1;
   return ap < bp ? -1 : 1;
 }
-var import_node_fs4, import_node_path5;
+var import_node_fs5, import_node_path5;
 var init_product = __esm({
   "../contrast-runtime-delivery/src/product.ts"() {
     "use strict";
-    import_node_fs4 = __toESM(require("node:fs"), 1);
+    import_node_fs5 = __toESM(require("node:fs"), 1);
     import_node_path5 = __toESM(require("node:path"), 1);
   }
 });
@@ -16217,7 +16223,7 @@ function createRuntimeDelivery(product) {
   function readConfig() {
     try {
       const parsed = JSON.parse(
-        import_node_fs5.default.readFileSync(product.configFile(), "utf8")
+        import_node_fs6.default.readFileSync(product.configFile(), "utf8")
       );
       return parsed && typeof parsed === "object" ? parsed : {};
     } catch {
@@ -16290,7 +16296,7 @@ function createRuntimeDelivery(product) {
     const setActive = opts.setActive !== false;
     const protectVersions = [version, ...opts.protectVersions ?? []];
     pruneLocalRetention({ protectVersions });
-    if (!opts.force && import_node_fs5.default.existsSync(import_node_path6.default.join(destDir, product.installedMarker))) {
+    if (!opts.force && import_node_fs6.default.existsSync(import_node_path6.default.join(destDir, product.installedMarker))) {
       if (setActive) product.writeActiveRuntime(version);
       pruneLocalRetention({ protectVersions });
       return {
@@ -16304,7 +16310,7 @@ function createRuntimeDelivery(product) {
       };
     }
     const tarUrl = entry.tarball || tarballUrl(version, cdnOrigin);
-    const downloadDir = import_node_fs5.default.mkdtempSync(
+    const downloadDir = import_node_fs6.default.mkdtempSync(
       import_node_path6.default.join(import_node_os2.default.tmpdir(), `${product.id}-runtime-download-`)
     );
     const runtimeArchivePath = import_node_path6.default.join(
@@ -16315,7 +16321,7 @@ function createRuntimeDelivery(product) {
       import_node_path6.default.dirname(destDir),
       `.installing-${version}-${process.pid}`
     );
-    import_node_fs5.default.rmSync(tmpDir, { recursive: true, force: true });
+    import_node_fs6.default.rmSync(tmpDir, { recursive: true, force: true });
     try {
       process.stderr.write(`${product.id}: downloading runtime ${version}\u2026
 `);
@@ -16328,20 +16334,20 @@ function createRuntimeDelivery(product) {
           `sha256 mismatch for runtime ${version}: expected ${entry.sha256}, actual ${actualSha}`
         );
       }
-      import_node_fs5.default.mkdirSync(tmpDir, { recursive: true });
+      import_node_fs6.default.mkdirSync(tmpDir, { recursive: true });
       await extractTarball(runtimeArchivePath, tmpDir);
-      if (!import_node_fs5.default.existsSync(import_node_path6.default.join(tmpDir, product.installedMarker))) {
+      if (!import_node_fs6.default.existsSync(import_node_path6.default.join(tmpDir, product.installedMarker))) {
         throw new Error(
           `extracted tarball for runtime ${version} is missing ${product.installedMarker}`
         );
       }
-      import_node_fs5.default.rmSync(destDir, { recursive: true, force: true });
-      import_node_fs5.default.renameSync(tmpDir, destDir);
+      import_node_fs6.default.rmSync(destDir, { recursive: true, force: true });
+      import_node_fs6.default.renameSync(tmpDir, destDir);
     } catch (err) {
-      import_node_fs5.default.rmSync(tmpDir, { recursive: true, force: true });
+      import_node_fs6.default.rmSync(tmpDir, { recursive: true, force: true });
       throw err;
     } finally {
-      import_node_fs5.default.rmSync(downloadDir, { recursive: true, force: true });
+      import_node_fs6.default.rmSync(downloadDir, { recursive: true, force: true });
     }
     if (setActive) product.writeActiveRuntime(version);
     pruneLocalRetention({ protectVersions });
@@ -16363,7 +16369,7 @@ function createRuntimeDelivery(product) {
     const pin = resolvePin();
     if (pin) {
       const activeVersion2 = product.readActiveRuntime();
-      const pinInstalled = import_node_fs5.default.existsSync(
+      const pinInstalled = import_node_fs6.default.existsSync(
         import_node_path6.default.join(product.runtimeDir(pin), product.installedMarker)
       );
       if (activeVersion2 === pin && pinInstalled) {
@@ -16413,7 +16419,7 @@ function createRuntimeDelivery(product) {
     }
     const activeVersion = product.readActiveRuntime();
     const activeDir = activeVersion ? product.runtimeDir(activeVersion) : null;
-    const activeInstalled = activeDir ? import_node_fs5.default.existsSync(import_node_path6.default.join(activeDir, product.installedMarker)) : false;
+    const activeInstalled = activeDir ? import_node_fs6.default.existsSync(import_node_path6.default.join(activeDir, product.installedMarker)) : false;
     const shouldInstall = !activeVersion || !activeInstalled || compareSemver(latestVersion, activeVersion) > 0;
     if (!shouldInstall) {
       return {
@@ -16488,7 +16494,7 @@ function createRuntimeDelivery(product) {
     let removeCacheFiles = [];
     if (markerOffset >= 0) {
       try {
-        removeCacheFiles = import_node_fs5.default.readdirSync(product.cacheDir(), { withFileTypes: true }).filter((entry) => {
+        removeCacheFiles = import_node_fs6.default.readdirSync(product.cacheDir(), { withFileTypes: true }).filter((entry) => {
           if (!entry.isFile()) return false;
           const complete = entry.name.startsWith(cachePrefix) && entry.name.endsWith(cacheSuffix);
           const partial = entry.name.startsWith(cachePrefix) && entry.name.endsWith(`${cacheSuffix}.partial`);
@@ -16508,10 +16514,10 @@ function createRuntimeDelivery(product) {
   function pruneLocalRetention(opts = {}) {
     const plan = planLocalRetention(opts);
     for (const version of plan.removeVersions) {
-      import_node_fs5.default.rmSync(product.runtimeDir(version), { recursive: true, force: true });
+      import_node_fs6.default.rmSync(product.runtimeDir(version), { recursive: true, force: true });
     }
     for (const cacheFile of plan.removeCacheFiles) {
-      import_node_fs5.default.rmSync(cacheFile, { force: true });
+      import_node_fs6.default.rmSync(cacheFile, { force: true });
     }
     return plan;
   }
@@ -16537,17 +16543,17 @@ async function downloadToFile(url, destPath) {
   if (!res.ok || !res.body) {
     throw new Error(`download failed: ${res.status} ${res.statusText} (${url})`);
   }
-  import_node_fs5.default.mkdirSync(import_node_path6.default.dirname(destPath), { recursive: true });
+  import_node_fs6.default.mkdirSync(import_node_path6.default.dirname(destPath), { recursive: true });
   const tmp = `${destPath}.partial`;
   try {
     await (0, import_promises3.pipeline)(
       import_node_stream.Readable.fromWeb(res.body),
-      import_node_fs5.default.createWriteStream(tmp)
+      import_node_fs6.default.createWriteStream(tmp)
     );
-    import_node_fs5.default.renameSync(tmp, destPath);
+    import_node_fs6.default.renameSync(tmp, destPath);
   } catch (err) {
     try {
-      import_node_fs5.default.unlinkSync(tmp);
+      import_node_fs6.default.unlinkSync(tmp);
     } catch {
     }
     throw err;
@@ -16556,7 +16562,7 @@ async function downloadToFile(url, destPath) {
 function sha256File(filePath) {
   return new Promise((resolve7, reject) => {
     const hash = import_node_crypto2.default.createHash("sha256");
-    const stream = import_node_fs5.default.createReadStream(filePath);
+    const stream = import_node_fs6.default.createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
     stream.on("end", () => resolve7(hash.digest("hex")));
@@ -16574,13 +16580,13 @@ function extractTarball(tarPath, destDir) {
     });
   });
 }
-var import_node_child_process2, import_node_crypto2, import_node_fs5, import_node_os2, import_node_path6, import_node_stream, import_promises3, DEFAULT_LOCAL_RUNTIME_RETENTION_COUNT;
+var import_node_child_process2, import_node_crypto2, import_node_fs6, import_node_os2, import_node_path6, import_node_stream, import_promises3, DEFAULT_LOCAL_RUNTIME_RETENTION_COUNT;
 var init_src = __esm({
   "../contrast-runtime-delivery/src/index.ts"() {
     "use strict";
     import_node_child_process2 = require("node:child_process");
     import_node_crypto2 = __toESM(require("node:crypto"), 1);
-    import_node_fs5 = __toESM(require("node:fs"), 1);
+    import_node_fs6 = __toESM(require("node:fs"), 1);
     import_node_os2 = __toESM(require("node:os"), 1);
     import_node_path6 = __toESM(require("node:path"), 1);
     import_node_stream = require("node:stream");
@@ -16786,7 +16792,7 @@ function loadStore() {
   const file = storeFile();
   let raw;
   try {
-    raw = import_node_fs6.default.readFileSync(file, "utf8");
+    raw = import_node_fs7.default.readFileSync(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return cloneEmpty();
     throw err;
@@ -16803,7 +16809,7 @@ function loadStore() {
   } catch (err) {
     const quarantine = `${file}.corrupt-${Date.now()}`;
     try {
-      import_node_fs6.default.renameSync(file, quarantine);
+      import_node_fs7.default.renameSync(file, quarantine);
       console.warn(
         `[sootsim] attached-projects.json was unparseable; quarantined to ${quarantine}. original error: ${err.message}`
       );
@@ -16814,16 +16820,16 @@ function loadStore() {
 }
 function writeStore(store) {
   const file = storeFile();
-  import_node_fs6.default.mkdirSync(import_node_path7.default.dirname(file), { recursive: true });
+  import_node_fs7.default.mkdirSync(import_node_path7.default.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-  const fd = import_node_fs6.default.openSync(tmp, "w", 384);
+  const fd = import_node_fs7.default.openSync(tmp, "w", 384);
   try {
-    import_node_fs6.default.writeFileSync(fd, JSON.stringify(store, null, 2));
-    import_node_fs6.default.fsyncSync(fd);
+    import_node_fs7.default.writeFileSync(fd, JSON.stringify(store, null, 2));
+    import_node_fs7.default.fsyncSync(fd);
   } finally {
-    import_node_fs6.default.closeSync(fd);
+    import_node_fs7.default.closeSync(fd);
   }
-  import_node_fs6.default.renameSync(tmp, file);
+  import_node_fs7.default.renameSync(tmp, file);
 }
 function mutateStore(fn) {
   const store = loadStore();
@@ -17009,7 +17015,7 @@ async function seedFromDemoAppRegistry() {
   if (apps.length === 0) return;
   mutateStore((store) => {
     for (const app of apps) {
-      if (!import_node_fs6.default.existsSync(app.dir)) continue;
+      if (!import_node_fs7.default.existsSync(app.dir)) continue;
       const cwd = import_node_path7.default.resolve(app.dir);
       const id = projectIdForCwd(cwd);
       if (store.attachedProjects.some((p) => p.id === id)) continue;
@@ -17031,12 +17037,12 @@ async function seedFromDemoAppRegistry() {
     }
   });
 }
-var import_node_crypto3, import_node_fs6, import_node_path7, overrideDir, COST_HISTORY_MAX_AGE_MS;
+var import_node_crypto3, import_node_fs7, import_node_path7, overrideDir, COST_HISTORY_MAX_AGE_MS;
 var init_attached_projects = __esm({
   "src/attached-projects.ts"() {
     "use strict";
     import_node_crypto3 = require("node:crypto");
-    import_node_fs6 = __toESM(require("node:fs"), 1);
+    import_node_fs7 = __toESM(require("node:fs"), 1);
     import_node_path7 = __toESM(require("node:path"), 1);
     init_home_paths();
     overrideDir = null;
@@ -17065,7 +17071,7 @@ function pidIsAlive(pid, sessionId) {
     return false;
   }
   if (sessionId) {
-    if (!import_node_fs7.default.existsSync(sessionDir(sessionId))) return false;
+    if (!import_node_fs8.default.existsSync(sessionDir(sessionId))) return false;
   }
   return true;
 }
@@ -17081,7 +17087,7 @@ function resolveSootsimInvocation() {
         import_node_path8.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
       ];
       for (const c of candidates) {
-        if (import_node_fs7.default.existsSync(c)) return { cmd: c, prefixArgs: [] };
+        if (import_node_fs8.default.existsSync(c)) return { cmd: c, prefixArgs: [] };
       }
     }
   }
@@ -17105,14 +17111,14 @@ function tryWorkspaceSootsim() {
     if (!sootsimDir) return null;
     const binaryName = `sootsim-${process.platform}-${process.arch}`;
     const distBinary = import_node_path8.default.join(sootsimDir, "dist-bin", binaryName);
-    if (import_node_fs7.default.existsSync(distBinary)) return { cmd: distBinary, prefixArgs: [] };
+    if (import_node_fs8.default.existsSync(distBinary)) return { cmd: distBinary, prefixArgs: [] };
     const distBin = import_node_path8.default.join(sootsimDir, "dist-cli", "bin.js");
-    if (import_node_fs7.default.existsSync(distBin)) {
+    if (import_node_fs8.default.existsSync(distBin)) {
       try {
         const src = import_node_path8.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
-        if (import_node_fs7.default.existsSync(src)) {
-          const srcMtime = import_node_fs7.default.statSync(src).mtimeMs;
-          const buildMtime = import_node_fs7.default.statSync(distBin).mtimeMs;
+        if (import_node_fs8.default.existsSync(src)) {
+          const srcMtime = import_node_fs8.default.statSync(src).mtimeMs;
+          const buildMtime = import_node_fs8.default.statSync(distBin).mtimeMs;
           if (buildMtime < srcMtime) {
             console.warn(
               `[rnx] dist-cli/bin.js is older than agent-wrapper.ts \u2014 rebuild with \`bun run --cwd packages/sootsim build:cli\`.`
@@ -17140,8 +17146,8 @@ function resolveSootsimPackageDir() {
   for (let i = 0; i < 8; i++) {
     const pkg = import_node_path8.default.join(cur, "package.json");
     try {
-      if (import_node_fs7.default.existsSync(pkg)) {
-        const parsed = JSON.parse(import_node_fs7.default.readFileSync(pkg, "utf8"));
+      if (import_node_fs8.default.existsSync(pkg)) {
+        const parsed = JSON.parse(import_node_fs8.default.readFileSync(pkg, "utf8"));
         if (parsed.name === rnxPublicBrand.packageName) return cur;
       }
     } catch {
@@ -17163,9 +17169,9 @@ function fileFromImportMeta() {
 }
 async function withStartLock(projectId, provider, fn) {
   const lockDir = import_node_path8.default.join(getUserDataDir(), "locks");
-  import_node_fs7.default.mkdirSync(lockDir, { recursive: true });
+  import_node_fs8.default.mkdirSync(lockDir, { recursive: true });
   try {
-    import_node_fs7.default.chmodSync(lockDir, 448);
+    import_node_fs8.default.chmodSync(lockDir, 448);
   } catch {
   }
   const lockPath = import_node_path8.default.join(lockDir, `start-${projectId}-${provider}.lock`);
@@ -17173,17 +17179,17 @@ async function withStartLock(projectId, provider, fn) {
   let fd = null;
   while (fd === null) {
     try {
-      fd = import_node_fs7.default.openSync(
+      fd = import_node_fs8.default.openSync(
         lockPath,
-        import_node_fs7.constants.O_WRONLY | import_node_fs7.constants.O_CREAT | import_node_fs7.constants.O_EXCL,
+        import_node_fs8.constants.O_WRONLY | import_node_fs8.constants.O_CREAT | import_node_fs8.constants.O_EXCL,
         384
       );
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       try {
-        const stale = Number(import_node_fs7.default.readFileSync(lockPath, "utf8").trim());
+        const stale = Number(import_node_fs8.default.readFileSync(lockPath, "utf8").trim());
         if (stale && !isProcessAlive(stale)) {
-          import_node_fs7.default.unlinkSync(lockPath);
+          import_node_fs8.default.unlinkSync(lockPath);
           continue;
         }
       } catch {
@@ -17197,15 +17203,15 @@ async function withStartLock(projectId, provider, fn) {
     }
   }
   try {
-    import_node_fs7.default.writeFileSync(fd, String(process.pid));
+    import_node_fs8.default.writeFileSync(fd, String(process.pid));
     return await fn();
   } finally {
     try {
-      import_node_fs7.default.closeSync(fd);
+      import_node_fs8.default.closeSync(fd);
     } catch {
     }
     try {
-      import_node_fs7.default.unlinkSync(lockPath);
+      import_node_fs8.default.unlinkSync(lockPath);
     } catch {
     }
   }
@@ -17220,24 +17226,24 @@ function isProcessAlive(pid) {
 }
 function mkfifoSync(p) {
   const parent = import_node_path8.default.dirname(p);
-  import_node_fs7.default.mkdirSync(parent, { recursive: true });
+  import_node_fs8.default.mkdirSync(parent, { recursive: true });
   try {
-    import_node_fs7.default.chmodSync(parent, 448);
+    import_node_fs8.default.chmodSync(parent, 448);
   } catch {
   }
-  if (import_node_fs7.default.existsSync(p)) {
+  if (import_node_fs8.default.existsSync(p)) {
     try {
-      const stat2 = import_node_fs7.default.statSync(p);
+      const stat2 = import_node_fs8.default.statSync(p);
       if (stat2.isFIFO()) {
         try {
-          import_node_fs7.default.chmodSync(p, 384);
+          import_node_fs8.default.chmodSync(p, 384);
         } catch {
         }
         return;
       }
-      import_node_fs7.default.unlinkSync(p);
+      import_node_fs8.default.unlinkSync(p);
     } catch {
-      import_node_fs7.default.unlinkSync(p);
+      import_node_fs8.default.unlinkSync(p);
     }
   }
   const result = (0, import_node_child_process3.spawnSync)("mkfifo", ["-m", "600", p]);
@@ -17278,9 +17284,9 @@ async function startSession(opts) {
     mkfifoSync(promptIn);
     mkfifoSync(eventsOut);
     const transcriptDir = import_node_path8.default.dirname(transcript);
-    import_node_fs7.default.mkdirSync(transcriptDir, { recursive: true });
+    import_node_fs8.default.mkdirSync(transcriptDir, { recursive: true });
     try {
-      import_node_fs7.default.chmodSync(transcriptDir, 448);
+      import_node_fs8.default.chmodSync(transcriptDir, 448);
     } catch {
     }
     const { cmd, prefixArgs } = resolveSootsimInvocation();
@@ -17331,7 +17337,7 @@ async function startSession(opts) {
         }
       }
       try {
-        import_node_fs7.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
+        import_node_fs8.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
       } catch {
       }
       updateSessionStatus(session.id, { status: "ended" });
@@ -17359,18 +17365,18 @@ async function sendPrompt(sessionId, prompt) {
     );
   }
   const fifo = promptFifoPath(sessionId);
-  if (!import_node_fs7.default.existsSync(fifo)) {
+  if (!import_node_fs8.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `prompt FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs7.default.openSync(fifo, import_node_fs7.constants.O_WRONLY);
+  const fd = import_node_fs8.default.openSync(fifo, import_node_fs8.constants.O_WRONLY);
   try {
     const wireText = encodeAgentPromptEnvelope(prompt);
     if (!wireText) {
       throw new AgentSessionError("EMPTY_PROMPT", "prompt text is empty");
     }
-    import_node_fs7.default.writeSync(fd, wireText + "\n");
+    import_node_fs8.default.writeSync(fd, wireText + "\n");
   } finally {
-    import_node_fs7.default.closeSync(fd);
+    import_node_fs8.default.closeSync(fd);
   }
   updateSessionStatus(sessionId, {
     lastPrompt: prompt.displayText ?? prompt.text,
@@ -17392,7 +17398,7 @@ async function endSession(sessionId) {
   const base = getUserDataDir();
   if (dir.startsWith(base)) {
     try {
-      import_node_fs7.default.rmSync(dir, { recursive: true, force: true });
+      import_node_fs8.default.rmSync(dir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -17400,11 +17406,11 @@ async function endSession(sessionId) {
 }
 function subscribeEvents(sessionId, onEvent) {
   const fifo = eventsFifoPath(sessionId);
-  if (!import_node_fs7.default.existsSync(fifo)) {
+  if (!import_node_fs8.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `events FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs7.default.openSync(fifo, import_node_fs7.constants.O_RDWR);
-  const stream = import_node_fs7.default.createReadStream("", { fd, autoClose: true });
+  const fd = import_node_fs8.default.openSync(fifo, import_node_fs8.constants.O_RDWR);
+  const stream = import_node_fs8.default.createReadStream("", { fd, autoClose: true });
   const rl = import_node_readline.default.createInterface({ input: stream, crlfDelay: Infinity });
   rl.on("line", (line) => {
     const event = parseAgentEventLine(line);
@@ -17415,7 +17421,7 @@ function subscribeEvents(sessionId, onEvent) {
     if (closed) return;
     closed = true;
     try {
-      import_node_fs7.default.writeSync(fd, "\n");
+      import_node_fs8.default.writeSync(fd, "\n");
     } catch {
     }
     try {
@@ -17429,7 +17435,7 @@ function subscribeEvents(sessionId, onEvent) {
   };
 }
 async function waitForFirstEvent(fifo, predicate, timeoutMs) {
-  const fd = import_node_fs7.default.openSync(fifo, import_node_fs7.constants.O_RDWR | import_node_fs7.constants.O_NONBLOCK);
+  const fd = import_node_fs8.default.openSync(fifo, import_node_fs8.constants.O_RDWR | import_node_fs8.constants.O_NONBLOCK);
   const buf = Buffer.alloc(8192);
   let leftover = "";
   const deadline = Date.now() + timeoutMs;
@@ -17437,7 +17443,7 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     while (Date.now() < deadline) {
       let n = 0;
       try {
-        n = import_node_fs7.default.readSync(fd, buf, 0, buf.length, null);
+        n = import_node_fs8.default.readSync(fd, buf, 0, buf.length, null);
       } catch (err) {
         if (err.code !== "EAGAIN") throw err;
         n = 0;
@@ -17457,16 +17463,16 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     }
     return null;
   } finally {
-    import_node_fs7.default.closeSync(fd);
+    import_node_fs8.default.closeSync(fd);
   }
 }
-var import_node_child_process3, import_node_crypto4, import_node_fs7, import_node_path8, import_node_readline, AgentSessionError;
+var import_node_child_process3, import_node_crypto4, import_node_fs8, import_node_path8, import_node_readline, AgentSessionError;
 var init_agent_sessions = __esm({
   "src/agent-sessions.ts"() {
     "use strict";
     import_node_child_process3 = require("node:child_process");
     import_node_crypto4 = require("node:crypto");
-    import_node_fs7 = __toESM(require("node:fs"), 1);
+    import_node_fs8 = __toESM(require("node:fs"), 1);
     import_node_path8 = __toESM(require("node:path"), 1);
     import_node_readline = __toESM(require("node:readline"), 1);
     init_agent_events();
@@ -17580,11 +17586,11 @@ function mapFrameworkToProjectFramework(fw) {
   if (fw === "one" || fw === "vxrn") return "one";
   return "unknown";
 }
-var import_node_fs8, import_node_path9, WS_OPEN, SESSION_STATUS_PERSIST_DELAY_MS, AgentHost;
+var import_node_fs9, import_node_path9, WS_OPEN, SESSION_STATUS_PERSIST_DELAY_MS, AgentHost;
 var init_agent_host = __esm({
   "src/host/agent-host.ts"() {
     "use strict";
-    import_node_fs8 = __toESM(require("node:fs"), 1);
+    import_node_fs9 = __toESM(require("node:fs"), 1);
     import_node_path9 = __toESM(require("node:path"), 1);
     init_dev_server_scanner();
     init_agent_sessions();
@@ -17795,10 +17801,10 @@ var init_agent_host = __esm({
       }
       getTranscript(sessionId) {
         const p = transcriptPath(sessionId);
-        if (!import_node_fs8.default.existsSync(p)) {
+        if (!import_node_fs9.default.existsSync(p)) {
           return { error: "transcript not found", code: "NO_TRANSCRIPT" };
         }
-        return import_node_fs8.default.readFileSync(p, "utf8");
+        return import_node_fs9.default.readFileSync(p, "utf8");
       }
       getPaths() {
         const dir = getUserDataDir();
@@ -18513,22 +18519,22 @@ function looksBinary(filePath, size) {
   if (size === 0) return false;
   let fd;
   try {
-    fd = import_node_fs9.default.openSync(filePath, "r");
+    fd = import_node_fs10.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);
+    const read = import_node_fs10.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);
+    if (fd !== void 0) import_node_fs10.default.closeSync(fd);
   }
 }
-var import_node_child_process5, import_node_fs9, import_node_path10, CheckoutRequiresGitError, BINARY_SNIFF_BYTES, LIST_FILES_TIMEOUT_MS, CheckoutFilePlane;
+var import_node_child_process5, import_node_fs10, 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_fs10 = __toESM(require("node:fs"), 1);
     import_node_path10 = __toESM(require("node:path"), 1);
     CheckoutRequiresGitError = class extends Error {
     };
@@ -18581,7 +18587,7 @@ var init_checkout_plane = __esm({
           if (!relative) continue;
           let stat2;
           try {
-            stat2 = import_node_fs9.default.statSync(import_node_path10.default.join(this.root, relative));
+            stat2 = import_node_fs10.default.statSync(import_node_path10.default.join(this.root, relative));
           } catch {
             continue;
           }
@@ -18608,15 +18614,15 @@ var init_checkout_plane = __esm({
         return resolved;
       }
       async read(planePath) {
-        return import_node_fs9.default.promises.readFile(this.absolute(planePath), "utf8");
+        return import_node_fs10.default.promises.readFile(this.absolute(planePath), "utf8");
       }
       async readBytes(planePath) {
-        return import_node_fs9.default.promises.readFile(this.absolute(planePath));
+        return import_node_fs10.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);
+        await import_node_fs10.default.promises.mkdir(import_node_path10.default.dirname(absolute), { recursive: true });
+        await import_node_fs10.default.promises.writeFile(absolute, content);
         this.entries.set(planePath, {
           size: content.byteLength,
           readOnly: false,
@@ -18625,7 +18631,7 @@ var init_checkout_plane = __esm({
         });
       }
       async delete(planePath) {
-        await import_node_fs9.default.promises.rm(this.absolute(planePath), { force: true });
+        await import_node_fs10.default.promises.rm(this.absolute(planePath), { force: true });
         this.entries.delete(planePath);
       }
     };
@@ -18633,11 +18639,11 @@ var init_checkout_plane = __esm({
 });
 
 // src/host/plane-host.ts
-var import_node_fs10, import_node_path11, import_plane, WS_OPEN2, PlaneNotRegisteredError, PlaneHost;
+var import_node_fs11, 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_fs11 = __toESM(require("node:fs"), 1);
     import_node_path11 = __toESM(require("node:path"), 1);
     import_plane = require("@contrast/harness/plane");
     init_checkout_plane();
@@ -18764,11 +18770,11 @@ var init_plane_host = __esm({
         const resolved = import_node_path11.default.resolve(root);
         let real;
         try {
-          real = import_node_fs10.default.realpathSync(resolved);
+          real = import_node_fs11.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}`);
+        if (!import_node_fs11.default.statSync(real).isDirectory()) throw new Error(`not a directory: ${real}`);
         return real;
       }
       respond(ws, id, result) {
@@ -21561,7 +21567,7 @@ function liveDevBridgeLockfiles() {
 function checkoutRoot(cwd) {
   let current = import_node_path13.default.resolve(cwd);
   while (true) {
-    if (import_node_fs11.default.existsSync(import_node_path13.default.join(current, ".git"))) return current;
+    if (import_node_fs12.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;
@@ -21998,11 +22004,11 @@ async function callInBridge(bridge, path20, ...args) {
 async function callInBridgeWrite(bridge, path20, ...args) {
   return bridge.send({ type: "call", path: path20, args, acquireLock: true });
 }
-var import_node_fs11, import_node_path13, import_ws3, RNX_PLACEMENT_ENV, resolvedWorld, BridgeSimLockedError;
+var import_node_fs12, import_node_path13, import_ws3, RNX_PLACEMENT_ENV, resolvedWorld, BridgeSimLockedError;
 var init_ws_bridge = __esm({
   "cli/ws-bridge.ts"() {
     "use strict";
-    import_node_fs11 = __toESM(require("node:fs"), 1);
+    import_node_fs12 = __toESM(require("node:fs"), 1);
     import_node_path13 = __toESM(require("node:path"), 1);
     import_ws3 = require("ws");
     init_bridge_constants();
@@ -22368,7 +22374,7 @@ function firstNamedFile(dir, names) {
   for (const name2 of names) {
     const candidate = import_node_path14.default.join(dir, name2);
     try {
-      if (import_node_fs12.default.statSync(candidate).isFile()) return candidate;
+      if (import_node_fs13.default.statSync(candidate).isFile()) return candidate;
     } catch {
     }
   }
@@ -22383,21 +22389,21 @@ function findSootSimAppConfig(dir) {
 function resolveAppProject(projectRoot) {
   const appDir = import_node_path14.default.resolve(projectRoot);
   try {
-    if (!import_node_fs12.default.statSync(appDir).isDirectory()) return null;
+    if (!import_node_fs13.default.statSync(appDir).isDirectory()) return null;
   } catch {
     return null;
   }
   const configPath = findSootSimAppConfig(appDir);
-  if (!configPath && !findExpoAppConfig(appDir) && !import_node_fs12.default.existsSync(import_node_path14.default.join(appDir, "package.json"))) {
+  if (!configPath && !findExpoAppConfig(appDir) && !import_node_fs13.default.existsSync(import_node_path14.default.join(appDir, "package.json"))) {
     return null;
   }
   return { appDir, configPath };
 }
-var import_node_fs12, import_node_path14, EXPO_APP_CONFIG_NAMES, SOOTSIM_APP_CONFIG_NAMES;
+var import_node_fs13, import_node_path14, EXPO_APP_CONFIG_NAMES, SOOTSIM_APP_CONFIG_NAMES;
 var init_app_project = __esm({
   "cli/app-project.ts"() {
     "use strict";
-    import_node_fs12 = __toESM(require("node:fs"), 1);
+    import_node_fs13 = __toESM(require("node:fs"), 1);
     import_node_path14 = __toESM(require("node:path"), 1);
     EXPO_APP_CONFIG_NAMES = [
       "app.config.js",
@@ -22536,7 +22542,7 @@ function discoverNativeLinkedAppFonts(opts) {
       scannedFontDirectories++;
       let entries;
       try {
-        entries = import_node_fs13.default.readdirSync(current.dir, { withFileTypes: true });
+        entries = import_node_fs14.default.readdirSync(current.dir, { withFileTypes: true });
       } catch {
         continue;
       }
@@ -22558,7 +22564,7 @@ function discoverNativeLinkedAppFonts(opts) {
   };
   try {
     const packageJson = JSON.parse(
-      import_node_fs13.default.readFileSync(import_node_path16.default.join(selectedAppDir, "package.json"), "utf8")
+      import_node_fs14.default.readFileSync(import_node_path16.default.join(selectedAppDir, "package.json"), "utf8")
     );
     const dependencyNames = /* @__PURE__ */ new Set();
     for (const field of ["dependencies", "devDependencies", "optionalDependencies"]) {
@@ -22600,7 +22606,7 @@ function discoverNativeLinkedAppFonts(opts) {
   }
   try {
     const configPath = import_node_path16.default.join(selectedAppDir, "react-native.config.js");
-    if (import_node_fs13.default.statSync(configPath).isFile()) {
+    if (import_node_fs14.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;
@@ -22619,7 +22625,7 @@ function discoverNativeLinkedAppFonts(opts) {
   if (platform === "ios") {
     const iosDir = import_node_path16.default.join(selectedAppDir, "ios");
     try {
-      const targetDirs = import_node_fs13.default.readdirSync(iosDir, { withFileTypes: true }).filter(
+      const targetDirs = import_node_fs14.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_path16.default.join(iosDir, "Info.plist")];
@@ -22629,7 +22635,7 @@ function discoverNativeLinkedAppFonts(opts) {
       for (const plistPath of plistPaths) {
         let parsed;
         try {
-          parsed = parsePlistSource(import_node_fs13.default.readFileSync(plistPath, "utf8"));
+          parsed = parsePlistSource(import_node_fs14.default.readFileSync(plistPath, "utf8"));
         } catch {
           continue;
         }
@@ -22646,7 +22652,7 @@ function discoverNativeLinkedAppFonts(opts) {
             const relative = import_node_path16.default.relative(selectedAppDir, candidate);
             if (relative.startsWith("..") || import_node_path16.default.isAbsolute(relative)) return false;
             try {
-              return import_node_fs13.default.statSync(candidate).isFile();
+              return import_node_fs14.default.statSync(candidate).isFile();
             } catch {
               return false;
             }
@@ -22692,11 +22698,11 @@ async function resolveMetroProjectRoot(bundleUrl, opts) {
 function encodeAppFontsWire(specs) {
   return specs.map((spec) => `${encodeURIComponent(spec.url)}::${encodeURIComponent(spec.family)}`).join(",");
 }
-var import_node_fs13, import_node_module2, import_node_path16, import_config_plugin_fonts, require3;
+var import_node_fs14, import_node_module2, import_node_path16, import_config_plugin_fonts, require3;
 var init_app_fonts = __esm({
   "cli/app-fonts.ts"() {
     "use strict";
-    import_node_fs13 = __toESM(require("node:fs"), 1);
+    import_node_fs14 = __toESM(require("node:fs"), 1);
     import_node_module2 = require("node:module");
     import_node_path16 = __toESM(require("node:path"), 1);
     import_config_plugin_fonts = require("sootsim-engine/engine/config-plugin-fonts");
@@ -23789,7 +23795,7 @@ function resolvePlaywright() {
         try {
           const modulePath = requireFromRoot.resolve(spec);
           const packageJsonPath = requireFromRoot.resolve(`${spec}/package.json`);
-          const parsed = JSON.parse((0, import_node_fs14.readFileSync)(packageJsonPath, "utf8"));
+          const parsed = JSON.parse((0, import_node_fs15.readFileSync)(packageJsonPath, "utf8"));
           if (!isRecord3(parsed) || typeof parsed.version !== "string") continue;
           const bin = parsed.bin;
           let binPath = null;
@@ -23802,7 +23808,7 @@ function resolvePlaywright() {
           }
           if (!binPath) continue;
           const cliPath = (0, import_node_path17.join)((0, import_node_path17.dirname)(packageJsonPath), binPath);
-          if (!(0, import_node_fs14.existsSync)(cliPath)) continue;
+          if (!(0, import_node_fs15.existsSync)(cliPath)) continue;
           return {
             spec,
             modulePath,
@@ -23841,7 +23847,7 @@ function probeBrowser(resolved, env) {
     return {
       ok: true,
       executablePath: parsed.executablePath,
-      exists: parsed.exists && (0, import_node_fs14.existsSync)(parsed.executablePath)
+      exists: parsed.exists && (0, import_node_fs15.existsSync)(parsed.executablePath)
     };
   } catch (error) {
     return {
@@ -23880,12 +23886,12 @@ ${detail}` : ""}`
   }
   return { ok: true, executablePath: after.executablePath, installed: true };
 }
-var import_node_child_process6, import_node_fs14, import_node_module4, import_node_path17, PLAYWRIGHT_BROWSER_PROBE;
+var import_node_child_process6, import_node_fs15, import_node_module4, import_node_path17, PLAYWRIGHT_BROWSER_PROBE;
 var init_playwright_provisioning = __esm({
   "cli/drivers/playwright-provisioning.ts"() {
     "use strict";
     import_node_child_process6 = require("node:child_process");
-    import_node_fs14 = require("node:fs");
+    import_node_fs15 = require("node:fs");
     import_node_module4 = require("node:module");
     import_node_path17 = require("node:path");
     PLAYWRIGHT_BROWSER_PROBE = `
@@ -24954,6 +24960,7 @@ __export(control_exports, {
   planBulkCloseTargets: () => planBulkCloseTargets,
   playwrightHostPidForSim: () => playwrightHostPidForSim,
   printConnectedSims: () => printConnectedSims,
+  printOpenedSim: () => printOpenedSim,
   resolveBundleTarget: () => resolveBundleTarget,
   resolveDefaultShellBaseUrl: () => resolveDefaultShellBaseUrl,
   resolveDriverConnectWaitOptions: () => resolveDriverConnectWaitOptions,
@@ -25062,14 +25069,14 @@ function assertExplicitBridgeLock(preferredPort, explicitPort, lock) {
 }
 async function ensureRuntimeForOpen() {
   const active = readActiveRuntime();
-  if (active && import_node_fs15.default.existsSync(runtimeDir(active))) return;
+  if (active && import_node_fs16.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_fs15.default.existsSync(entry)) {
+  if (entry && import_node_fs16.default.existsSync(entry)) {
     return (0, import_node_child_process7.spawn)(process.execPath, [entry, ...args], {
       detached: true,
       stdio: "ignore",
@@ -25238,7 +25245,7 @@ function parseOpenRuntimeConfig(args) {
       }
       const moduleName = raw.slice(0, eqIndex).trim();
       const filePath = normalizeReplacementPath(raw.slice(eqIndex + 1).trim());
-      if (!import_node_fs15.default.existsSync(filePath)) {
+      if (!import_node_fs16.default.existsSync(filePath)) {
         console.error(`  rnx open: replacement file not found: ${filePath}`);
         rnxExit(1);
       }
@@ -25269,7 +25276,7 @@ async function resolveOpenAppProject(resolvedBundle) {
   return advertisedRoot ? resolveAppProject(advertisedRoot) : null;
 }
 async function ensureConfiguredRuntime(version) {
-  if (import_node_fs15.default.existsSync(import_node_path18.default.join(runtimeDir(version), "index.html"))) return;
+  if (import_node_fs16.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,
@@ -25629,7 +25636,7 @@ function playwrightHostPidForSim(sim) {
 function signalDriverLaunchConnected(result) {
   if (!result.connectAckFile) return false;
   try {
-    import_node_fs15.default.writeFileSync(
+    import_node_fs16.default.writeFileSync(
       result.connectAckFile,
       `${JSON.stringify({ connectedAt: Date.now(), pid: result.pid ?? null })}
 `,
@@ -25643,7 +25650,7 @@ function signalDriverLaunchConnected(result) {
 function printDriverDiagnosticLogTail(result) {
   if (!result.diagnosticLogPath) return;
   try {
-    const detail = import_node_fs15.default.readFileSync(result.diagnosticLogPath, "utf8").trim();
+    const detail = import_node_fs16.default.readFileSync(result.diagnosticLogPath, "utf8").trim();
     if (!detail) {
       console.error(`  ${import_node_path18.default.basename(result.diagnosticLogPath)} was empty`);
       return;
@@ -25738,10 +25745,24 @@ function printOpenedSim(openUrl2, sim, mode, quiet = false) {
     if (!value) return value;
     try {
       const parsed = new URL(value);
-      if (parsed.searchParams.has("sootsimConfig")) {
-        parsed.searchParams.set("sootsimConfig", "[redacted]");
-        return parsed.toString();
+      let changed = false;
+      if (parsed.searchParams.has(SOOTSIM_CONFIG_QUERY_PARAM)) {
+        parsed.searchParams.set(SOOTSIM_CONFIG_QUERY_PARAM, "[redacted]");
+        changed = true;
+      }
+      const bundle = parsed.searchParams.get("bundle");
+      if (bundle) {
+        try {
+          const parsedBundle = new URL(bundle);
+          if (parsedBundle.searchParams.has(SOOTSIM_CONFIG_QUERY_PARAM)) {
+            parsedBundle.searchParams.set(SOOTSIM_CONFIG_QUERY_PARAM, "[redacted]");
+            parsed.searchParams.set("bundle", parsedBundle.toString());
+            changed = true;
+          }
+        } catch {
+        }
       }
+      if (changed) return parsed.toString();
     } catch {
     }
     return value;
@@ -26452,12 +26473,12 @@ async function runCloseCommand(args, opts = {}) {
     bridge.close();
   }
 }
-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 import_node_child_process7, import_node_fs16, 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_process7 = require("node:child_process");
-    import_node_fs15 = __toESM(require("node:fs"), 1);
+    import_node_fs16 = __toESM(require("node:fs"), 1);
     import_node_os3 = __toESM(require("node:os"), 1);
     import_node_path18 = __toESM(require("node:path"), 1);
     import_settings = require("sootsim-engine/settings");
@@ -27377,25 +27398,25 @@ function normalizeSession(input) {
 }
 function readSharedDesktopAuthSession() {
   const filepath = getSharedDesktopAuthFilePath();
-  if (!(0, import_node_fs16.existsSync)(filepath)) return null;
+  if (!(0, import_node_fs17.existsSync)(filepath)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs16.readFileSync)(filepath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs17.readFileSync)(filepath, "utf8"));
     const normalized = normalizeSession(parsed);
     if (!normalized) {
-      (0, import_node_fs16.rmSync)(filepath, { force: true });
+      (0, import_node_fs17.rmSync)(filepath, { force: true });
       return null;
     }
     return normalized;
   } catch {
-    (0, import_node_fs16.rmSync)(filepath, { force: true });
+    (0, import_node_fs17.rmSync)(filepath, { force: true });
     return null;
   }
 }
-var import_node_fs16, import_node_path19, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
+var import_node_fs17, import_node_path19, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
 var init_shared_session = __esm({
   "src/auth/shared-session.ts"() {
     "use strict";
-    import_node_fs16 = require("node:fs");
+    import_node_fs17 = require("node:fs");
     import_node_path19 = require("node:path");
     init_home_paths();
     SESSION_VERSION = 1;