rnxsim 0.1.375 → 0.1.377

package/dist-lib/host/bridge-host.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.375 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.377 | (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;
@@ -113,6 +113,7 @@ var import_child_process = require("child_process");
 var import_promises2 = require("fs/promises");
 var import_http = __toESM(require("http"), 1);
 var import_net = __toESM(require("net"), 1);
+var import_node_fs2 = require("node:fs");
 var import_node_path3 = require("node:path");
 
 // src/backend-origin.ts
@@ -131,20 +132,20 @@ function isLoopbackHost(hostname) {
 }
 
 // src/config.ts
-var SOOTSIM_CONFIG_QUERY_PARAM = "sootsimConfig";
+var RNX_CONFIG_QUERY_PARAM = "rnxConfig";
 function hasOwnKeys(value) {
   return !!value && Object.keys(value).length > 0;
 }
-function hasSootSimConfig(config) {
+function hasRNXConfig(config) {
   if (!config) return false;
   return typeof config.runtimeVersion === "string" && config.runtimeVersion.length > 0 || hasOwnKeys(config.modules) || hasOwnKeys(config.turboModules) || hasOwnKeys(config.nativeModules) || hasOwnKeys(config.env) || hasOwnKeys(config.network?.remap) || hasOwnKeys(config.settings) || hasOwnKeys(config.initialState);
 }
-function applySootSimConfigToUrl(url, config) {
+function applyRNXConfigToUrl(url, config) {
   const parsed = new URL(url);
-  if (hasSootSimConfig(config)) {
-    parsed.searchParams.set(SOOTSIM_CONFIG_QUERY_PARAM, JSON.stringify(config));
+  if (hasRNXConfig(config)) {
+    parsed.searchParams.set(RNX_CONFIG_QUERY_PARAM, JSON.stringify(config));
   } else {
-    parsed.searchParams.delete(SOOTSIM_CONFIG_QUERY_PARAM);
+    parsed.searchParams.delete(RNX_CONFIG_QUERY_PARAM);
   }
   return parsed.toString();
 }
@@ -802,10 +803,23 @@ 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;
-  const configured = knownApp?.runtimeConfig ? applySootSimConfigToUrl(bundleUrl, knownApp.runtimeConfig) : bundleUrl;
+  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 ? applyRNXConfigToUrl(bundleUrl, knownApp.runtimeConfig) : bundleUrl;
   return normalizeNativeDevBundleUrl(configured);
 }
 function isDirectOneBundleUrl(bundleUrl) {
@@ -1141,7 +1155,7 @@ var SOOTSIM_BRIDGE_SIM_CLOSE_CODE = 4001;
 var SOOTSIM_BRIDGE_SIM_CLOSE_REASON = "sootsim close";
 
 // src/cli-version.ts
-var import_node_fs2 = require("node:fs");
+var import_node_fs3 = require("node:fs");
 var import_node_url2 = require("node:url");
 
 // src/public-brand.ts
@@ -1159,13 +1173,17 @@ var import_meta = {};
 var cached2 = null;
 function getCliVersion() {
   if (cached2 != null) return cached2;
+  if (typeof __RNX_CLI_VERSION__ !== "undefined" && typeof __RNX_CLI_VERSION__ === "string" && __RNX_CLI_VERSION__) {
+    cached2 = __RNX_CLI_VERSION__;
+    return cached2;
+  }
   const candidates = [
     () => (0, import_node_url2.fileURLToPath)(import_meta.resolve(`${rnxPublicBrand.packageName}/package.json`)),
     () => (0, import_node_url2.fileURLToPath)(new URL("../package.json", __sootsim_import_meta_url))
   ];
   for (const resolve2 of candidates) {
     try {
-      const version = JSON.parse((0, import_node_fs2.readFileSync)(resolve2(), "utf8")).version;
+      const version = JSON.parse((0, import_node_fs3.readFileSync)(resolve2(), "utf8")).version;
       if (typeof version === "string" && version) {
         cached2 = version;
         return cached2;
@@ -1179,19 +1197,19 @@ function getCliVersion() {
 
 // src/home-paths.ts
 var import_node_crypto = require("node:crypto");
-var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_node_fs4 = __toESM(require("node:fs"), 1);
 var import_node_os = require("node:os");
 var import_node_path4 = __toESM(require("node:path"), 1);
-var SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
+var RNX_HOME_ENV = "RNX_HOME";
 var ACTIVE_RUNTIME_FILE = "active";
 var DAEMON_LOCKFILE = "daemon.json";
 var DEV_BRIDGES_DIR = "dev-bridges";
 var CONFIG_FILE = "config.json";
 var DAEMON_HEARTBEAT_STALE_MS = 3e4;
-function sootsimHomeDir() {
-  const override = process.env[SOOTSIM_HOME_ENV];
+function rnxHomeDir() {
+  const override = process.env[RNX_HOME_ENV];
   if (override && override.length > 0) return import_node_path4.default.resolve(override);
-  return import_node_path4.default.join((0, import_node_os.homedir)(), ".sootsim");
+  return import_node_path4.default.join((0, import_node_os.homedir)(), ".rnx");
 }
 function isSootsimDevCheckout() {
   if (process.env.SOOTSIM_FORCE_DAEMON_INSTALL === "1") return false;
@@ -1201,14 +1219,14 @@ 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;
   }
 }
 function runtimesDir() {
-  return import_node_path4.default.join(sootsimHomeDir(), "runtimes");
+  return import_node_path4.default.join(rnxHomeDir(), "runtimes");
 }
 function runtimeDir(version) {
   return import_node_path4.default.join(runtimesDir(), version);
@@ -1217,25 +1235,25 @@ function activeRuntimeFile() {
   return import_node_path4.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
 }
 function electronDir() {
-  return import_node_path4.default.join(sootsimHomeDir(), "electron");
+  return import_node_path4.default.join(rnxHomeDir(), "electron");
 }
 function electronUserDataDir() {
   return import_node_path4.default.join(electronDir(), "userData");
 }
 function profilesDir() {
-  return import_node_path4.default.join(sootsimHomeDir(), "profiles");
+  return import_node_path4.default.join(rnxHomeDir(), "profiles");
 }
 function cameraFixturesDir() {
-  return import_node_path4.default.join(sootsimHomeDir(), "camera-fixtures");
+  return import_node_path4.default.join(rnxHomeDir(), "camera-fixtures");
 }
 function cacheDir() {
-  return import_node_path4.default.join(sootsimHomeDir(), "cache");
+  return import_node_path4.default.join(rnxHomeDir(), "cache");
 }
 function daemonLockfilePath() {
-  return import_node_path4.default.join(sootsimHomeDir(), DAEMON_LOCKFILE);
+  return import_node_path4.default.join(rnxHomeDir(), DAEMON_LOCKFILE);
 }
 function devBridgesDir() {
-  return import_node_path4.default.join(sootsimHomeDir(), DEV_BRIDGES_DIR);
+  return import_node_path4.default.join(rnxHomeDir(), DEV_BRIDGES_DIR);
 }
 function devBridgeLockfilePath(bridgePort) {
   if (!Number.isInteger(bridgePort) || bridgePort <= 0) {
@@ -1244,11 +1262,11 @@ function devBridgeLockfilePath(bridgePort) {
   return import_node_path4.default.join(devBridgesDir(), `${bridgePort}.json`);
 }
 function configFilePath() {
-  return import_node_path4.default.join(sootsimHomeDir(), CONFIG_FILE);
+  return import_node_path4.default.join(rnxHomeDir(), CONFIG_FILE);
 }
 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 {
@@ -1256,7 +1274,7 @@ function readSharedConfig() {
   }
 }
 function writeSharedConfig(patch) {
-  ensureSootsimHome();
+  ensureRnxHome();
   const current = readSharedConfig();
   const next = { ...current, ...patch };
   if (patch.settings && typeof patch.settings === "object") {
@@ -1266,39 +1284,39 @@ 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 runtimeUpgradeNoticePath() {
-  return import_node_path4.default.join(sootsimHomeDir(), "runtime-upgraded.json");
+  return import_node_path4.default.join(rnxHomeDir(), "runtime-upgraded.json");
 }
 function writeRuntimeUpgradeNotice(notice) {
-  ensureSootsimHome();
+  ensureRnxHome();
   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 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 });
+function ensureRnxHome() {
+  import_node_fs4.default.mkdirSync(rnxHomeDir(), { 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() {
@@ -1306,7 +1324,7 @@ 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;
@@ -1315,10 +1333,10 @@ var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
 var DAEMON_CLAIM_STALE_MS = 3e4;
 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"))) {
@@ -1326,7 +1344,7 @@ function readDaemonLockfile() {
       }
       return null;
     } finally {
-      import_node_fs3.default.closeSync(fd);
+      import_node_fs4.default.closeSync(fd);
     }
   } catch {
     return null;
@@ -1354,7 +1372,7 @@ function isDaemonLockfileFresh(lock, now = Date.now()) {
   }
 }
 function writeDaemonLockfile(data) {
-  ensureSootsimHome();
+  ensureRnxHome();
   const lockfilePath = daemonLockfilePath();
   const existing = readDaemonLockfile();
   if (!existing) {
@@ -1365,28 +1383,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;
@@ -1397,17 +1415,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 {
     }
   }
@@ -1431,7 +1449,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;
   }
@@ -1455,7 +1473,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;
@@ -1465,11 +1483,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 {
     }
   }
@@ -1479,12 +1497,12 @@ 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 {
   }
 }
 function claimDaemonLockfile(data) {
-  ensureSootsimHome();
+  ensureRnxHome();
   if (!acquireDaemonClaim(data)) return false;
   try {
     const existing = readDaemonLockfile();
@@ -1498,7 +1516,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;
       }
@@ -1512,16 +1530,16 @@ 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 {
   }
 }
@@ -1534,21 +1552,21 @@ var import_url = require("url");
 // ../contrast-runtime-delivery/src/index.ts
 var import_node_child_process = require("node:child_process");
 var import_node_crypto2 = __toESM(require("node:crypto"), 1);
-var import_node_fs5 = __toESM(require("node:fs"), 1);
+var import_node_fs6 = __toESM(require("node:fs"), 1);
 var import_node_os2 = __toESM(require("node:os"), 1);
 var import_node_path6 = __toESM(require("node:path"), 1);
 var import_node_stream = require("node:stream");
 var import_promises3 = require("node:stream/promises");
 
 // ../contrast-runtime-delivery/src/product.ts
-var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_fs5 = __toESM(require("node:fs"), 1);
 var import_node_path5 = __toESM(require("node:path"), 1);
 function isValidRuntimeVersion(value) {
   return value.length <= 100 && /^[0-9A-Za-z][0-9A-Za-z._+-]*$/.test(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 [];
   }
@@ -1584,7 +1602,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 {
@@ -1657,7 +1675,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 {
@@ -1671,7 +1689,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(
@@ -1682,7 +1700,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
 `);
@@ -1695,20 +1713,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 });
@@ -1730,7 +1748,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) {
@@ -1780,7 +1798,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 {
@@ -1855,7 +1873,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`);
@@ -1875,10 +1893,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;
   }
@@ -1904,17 +1922,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;
@@ -1923,7 +1941,7 @@ async function downloadToFile(url, destPath) {
 function sha256File(filePath) {
   return new Promise((resolve2, 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", () => resolve2(hash.digest("hex")));
@@ -1958,7 +1976,7 @@ function findMonorepoRoot() {
   return null;
 }
 function resolveDevCheckoutRuntimeRoot() {
-  if (process.env.SOOTSIM_HOME && readActiveRuntime()) return null;
+  if (process.env.RNX_HOME && readActiveRuntime()) return null;
   const root = findMonorepoRoot();
   if (!root) return null;
   const devBuild = import_path.default.join(root, "public/sootsim");
@@ -2008,9 +2026,9 @@ function resolveRuntimeRootForHostname(hostname) {
 
 // src/runtime-delivery.ts
 var DEFAULT_RUNTIME_CDN_ORIGIN = "https://contrast.dev";
-var SOOTSIM_CHANGELOG_URL = `${rnxPublicBrand.origin}/changelog`;
-var SOOTSIM_RUNTIME_PRODUCT = {
-  id: "sootsim",
+var RNX_CHANGELOG_URL = `${rnxPublicBrand.origin}/changelog`;
+var RNX_RUNTIME_PRODUCT = {
+  id: "rnx",
   defaultCdnOrigin: DEFAULT_RUNTIME_CDN_ORIGIN,
   manifestPath: "/runtimes/manifest.json",
   tarballPath: (version) => `/runtimes/sootsim-runtime-${version}.tar.gz`,
@@ -2019,10 +2037,10 @@ var SOOTSIM_RUNTIME_PRODUCT = {
   // vite/metro plugins serve, so its absence means the tarball is not one.
   installedMarker: "index.html",
   env: {
-    cdnOrigin: "SOOTSIM_CDN_ORIGIN",
-    channel: "SOOTSIM_RUNTIME_CHANNEL"
+    cdnOrigin: "RNX_CDN_ORIGIN",
+    channel: "RNX_RUNTIME_CHANNEL"
   },
-  ensureHome: ensureSootsimHome,
+  ensureHome: ensureRnxHome,
   configFile: configFilePath,
   runtimesDir,
   runtimeDir,
@@ -2030,16 +2048,16 @@ var SOOTSIM_RUNTIME_PRODUCT = {
   readActiveRuntime,
   writeActiveRuntime
 };
-var sootsimRuntime = createRuntimeDelivery(SOOTSIM_RUNTIME_PRODUCT);
+var rnxRuntime = createRuntimeDelivery(RNX_RUNTIME_PRODUCT);
 
 // src/host/agent-host.ts
-var import_node_fs8 = __toESM(require("node:fs"), 1);
+var import_node_fs9 = __toESM(require("node:fs"), 1);
 var import_node_path9 = __toESM(require("node:path"), 1);
 
 // src/agent-sessions.ts
 var import_node_child_process2 = require("node:child_process");
 var import_node_crypto4 = require("node:crypto");
-var import_node_fs7 = __toESM(require("node:fs"), 1);
+var import_node_fs8 = __toESM(require("node:fs"), 1);
 var import_node_path8 = __toESM(require("node:path"), 1);
 var import_node_readline = __toESM(require("node:readline"), 1);
 
@@ -2084,7 +2102,7 @@ function encodeAgentPromptEnvelope(input) {
 
 // src/attached-projects.ts
 var import_node_crypto3 = require("node:crypto");
-var import_node_fs6 = __toESM(require("node:fs"), 1);
+var import_node_fs7 = __toESM(require("node:fs"), 1);
 var import_node_path7 = __toESM(require("node:path"), 1);
 var overrideDir = null;
 function userDataDir() {
@@ -2111,7 +2129,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;
@@ -2128,7 +2146,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}`
       );
@@ -2139,16 +2157,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();
@@ -2335,7 +2353,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;
@@ -2379,13 +2397,13 @@ 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;
 }
 function resolveSootsimInvocation() {
-  if (process.env.SOOTSIM_BIN) {
-    return { cmd: process.env.SOOTSIM_BIN, prefixArgs: [] };
+  if (process.env.RNX_BIN) {
+    return { cmd: process.env.RNX_BIN, prefixArgs: [] };
   }
   if (process.versions.electron) {
     const resourcesPath = process.resourcesPath;
@@ -2395,7 +2413,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: [] };
       }
     }
   }
@@ -2408,7 +2426,7 @@ function resolveSootsimInvocation() {
   }
   if (!argv1 || argv1.includes("/.bin/")) {
     throw new Error(
-      "rnx CLI not found. set SOOTSIM_BIN to the path of the rnx binary, or build the workspace CLI via `bun run --cwd packages/sootsim build:cli`."
+      "rnx CLI not found. set RNX_BIN to the path of the rnx binary, or build the workspace CLI via `bun run --cwd packages/sootsim build:cli`."
     );
   }
   return { cmd: argv0, prefixArgs: [] };
@@ -2417,16 +2435,16 @@ function tryWorkspaceSootsim() {
   try {
     const sootsimDir = resolveSootsimPackageDir();
     if (!sootsimDir) return null;
-    const binaryName = `sootsim-${process.platform}-${process.arch}`;
+    const binaryName = `rnx-${process.platform === "win32" ? "windows" : process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`;
     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\`.`
@@ -2454,8 +2472,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 {
@@ -2477,9 +2495,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`);
@@ -2487,17 +2505,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 {
@@ -2511,15 +2529,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 {
     }
   }
@@ -2534,24 +2552,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_process2.spawnSync)("mkfifo", ["-m", "600", p]);
@@ -2599,9 +2617,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();
@@ -2652,7 +2670,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" });
@@ -2680,18 +2698,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,
@@ -2713,7 +2731,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 {
     }
   }
@@ -2721,11 +2739,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);
@@ -2736,7 +2754,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 {
@@ -2750,7 +2768,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;
@@ -2758,7 +2776,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;
@@ -2778,7 +2796,7 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     }
     return null;
   } finally {
-    import_node_fs7.default.closeSync(fd);
+    import_node_fs8.default.closeSync(fd);
   }
 }
 
@@ -3067,10 +3085,10 @@ var AgentHost = class {
   }
   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();
@@ -3766,13 +3784,88 @@ async function openUrl(url, options = {}) {
 }
 
 // src/host/plane-host.ts
-var import_node_fs10 = __toESM(require("node:fs"), 1);
+var import_node_fs11 = __toESM(require("node:fs"), 1);
 var import_node_path11 = __toESM(require("node:path"), 1);
-var import_plane = require("@contrast/harness/plane");
+
+// ../contrast-harness/src/planeProtocol.ts
+var PLANE_FLAG_READ_ONLY = 1;
+var PLANE_FLAG_BINARY = 2;
+function encodeBase64(bytes) {
+  let binary = "";
+  const CHUNK = 32768;
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+  }
+  return btoa(binary);
+}
+function decodeBase64(value) {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function indexVersion(index) {
+  let a = 2166136261;
+  let b = 16777619;
+  for (const key of [...index.keys()].sort()) {
+    const meta = index.get(key);
+    if (!meta) continue;
+    const line = `${key} ${meta.size} ${meta.readOnly ? 1 : 0}${meta.binary ? 1 : 0} ${meta.hash ?? ""}`;
+    for (let i = 0; i < line.length; i++) {
+      const c = line.charCodeAt(i);
+      a = Math.imul(a ^ c, 16777619);
+      b = Math.imul(b + c, 2246822507) ^ b >>> 13;
+    }
+  }
+  return `${(a >>> 0).toString(36)}${(b >>> 0).toString(36)}-${index.size}`;
+}
+function serializeIndex(index) {
+  const out = [];
+  for (const [key, meta] of index) {
+    const flags = (meta.readOnly ? PLANE_FLAG_READ_ONLY : 0) | (meta.binary ? PLANE_FLAG_BINARY : 0);
+    out.push(meta.hash ? [key, meta.size, flags, meta.hash] : [key, meta.size, flags]);
+  }
+  return out;
+}
+async function dispatchPlaneCommand(plane, type, msg, mutationOptions) {
+  switch (type) {
+    case "plane:index":
+    case "plane:refresh": {
+      await plane.refresh();
+      const version = indexVersion(plane.index());
+      if (msg.sinceVersion && msg.sinceVersion === version) {
+        return { result: { version, unchanged: true }, version };
+      }
+      return { result: { version, entries: serializeIndex(plane.index()) }, version };
+    }
+    case "plane:read":
+      return { result: { content: await plane.read(String(msg.path)) } };
+    case "plane:read-bytes":
+      return { result: { base64: encodeBase64(await plane.readBytes(String(msg.path))) } };
+    case "plane:write": {
+      mutationOptions?.signal?.throwIfAborted();
+      await plane.write(
+        String(msg.path),
+        decodeBase64(String(msg.base64 ?? "")),
+        mutationOptions
+      );
+      const version = indexVersion(plane.index());
+      return { result: { version }, version };
+    }
+    case "plane:delete": {
+      mutationOptions?.signal?.throwIfAborted();
+      await plane.delete(String(msg.path), mutationOptions);
+      const version = indexVersion(plane.index());
+      return { result: { version }, version };
+    }
+    default:
+      return null;
+  }
+}
 
 // cli/commands/box/checkout-plane.ts
 var import_node_child_process4 = require("node:child_process");
-var import_node_fs9 = __toESM(require("node:fs"), 1);
+var import_node_fs10 = __toESM(require("node:fs"), 1);
 var import_node_path10 = __toESM(require("node:path"), 1);
 var CheckoutRequiresGitError = class extends Error {
 };
@@ -3782,14 +3875,14 @@ 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 CheckoutFilePlane = class {
@@ -3839,7 +3932,7 @@ var CheckoutFilePlane = class {
       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;
       }
@@ -3866,15 +3959,15 @@ var CheckoutFilePlane = class {
     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,
@@ -3883,7 +3976,7 @@ var CheckoutFilePlane = class {
     });
   }
   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);
   }
 };
@@ -3979,7 +4072,7 @@ var PlaneHost = class {
         const entry = {
           root,
           plane,
-          version: (0, import_plane.indexVersion)(plane.index()),
+          version: indexVersion(plane.index()),
           sockets: /* @__PURE__ */ new Set([ws])
         };
         this.open.set(planeId, entry);
@@ -3993,7 +4086,7 @@ var PlaneHost = class {
       }
       default: {
         const entry = this.entry(msg);
-        const handled = await (0, import_plane.dispatchPlaneCommand)(entry.plane, type, msg);
+        const handled = await dispatchPlaneCommand(entry.plane, type, msg);
         if (!handled) throw new Error(`unknown plane command: ${type}`);
         if (handled.version) entry.version = handled.version;
         return handled.result;
@@ -4012,11 +4105,11 @@ var PlaneHost = class {
     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) {
@@ -4747,7 +4840,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
           return;
         }
         if (msg.type === "runtime:list") {
-          const versions = sootsimRuntime.listInstalled();
+          const versions = rnxRuntime.listInstalled();
           const active = this.getActiveRuntime();
           const reply = {
             type: "runtime:list:ok",
@@ -4764,7 +4857,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
         }
         if (msg.type === "runtime:use") {
           const version = typeof msg.version === "string" ? msg.version : "";
-          const installed = sootsimRuntime.listInstalled();
+          const installed = rnxRuntime.listInstalled();
           if (!installed.includes(version)) {
             try {
               ws.send(
@@ -5127,7 +5220,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
     this.wsHeartbeatTimer.unref();
     if (this.shouldWriteLockfile) {
       try {
-        ensureSootsimHome();
+        ensureRnxHome();
         const claimed = claimDaemonLockfile(this.buildLockfileSnapshot());
         if (!claimed) {
           throw new Error(
@@ -5257,7 +5350,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
     return this.inflightScan;
   }
   // serves one staged camera fixture. addressed by basename inside
-  // ~/.sootsim/camera-fixtures, never by a caller-supplied path, so there is
+  // ~/.rnx/camera-fixtures, never by a caller-supplied path, so there is
   // no traversal surface to defend: a name that is not a plain basename is
   // rejected outright. range support is not optional here — chrome asks for
   // byte ranges on media and cannot seek or loop a fixture without it.
@@ -5367,8 +5460,8 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
   }
   startRuntimeUpdater() {
     if (!this.shouldWriteLockfile || this.runtimeUpdateTimer) return;
-    if (import_fs2.default.existsSync(import_path2.default.join(sootsimHomeDir(), "runtime-update-disabled"))) return;
-    if (process.env.SOOTSIM_HOME && isSootsimDevCheckout() && !readActiveRuntime()) {
+    if (import_fs2.default.existsSync(import_path2.default.join(rnxHomeDir(), "runtime-update-disabled"))) return;
+    if (process.env.RNX_HOME && isSootsimDevCheckout() && !readActiveRuntime()) {
       return;
     }
     void this.runRuntimeUpdate("startup");
@@ -5385,7 +5478,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
         if (reason === "startup") {
           process.stderr.write("rnx: checking for runtime updates\u2026\n");
         }
-        const result = await sootsimRuntime.updateToLatest({
+        const result = await rnxRuntime.updateToLatest({
           protectVersions: this.connectedRuntimeVersions()
         });
         if (!result.updated || !result.latestVersion) {