rnxsim 0.1.375 → 0.1.377

package/dist-lib/skills.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;
@@ -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));
@@ -1791,9 +1783,9 @@ var init_registry = __esm({
             coverage: 0.9,
             coverageSource: "estimated",
             capabilityCoverage: CAPABILITY_INVENTORY_PACKAGE_COVERAGE["react-native-gesture-handler"],
-            note: "tap, pan, pinch, rotation, fling, long press, race, manual, simultaneous",
-            working: "GestureDetector, Gesture.Tap/Pan/Pinch/Rotation/Fling/LongPress/Manual/Race/Simultaneous/Exclusive/Hover, simultaneousWithExternalGesture/requireExternalGestureToFail/blocksExternalGesture, ScrollView/FlatList, Switch/RefreshControl, Pressable/Text, Touchables, BaseButton/RawButton/RectButton/BorderlessButton/PureNativeButton, Swipeable, ReanimatedSwipeable, DrawerLayout (the upstream component running on this seam: renderNavigationView, drawerPosition/drawerType/drawerWidth/edgeWidth, openDrawer/closeDrawer, edge-swipe drag, onDrawerOpen/onDrawerClose/onDrawerStateChanged), GestureHandlerRootView, createNativeWrapper, gestureHandlerRootHOC, PointerType/MouseButton/HoverEffect exports, velocity tracking, activeOffsets, multi-tap",
-            missing: "Gesture.ForceTouch() is absent; ForceTouchGestureHandler renders its children and reports forceTouchAvailable false, as upstream does on hardware without 3D Touch"
+            note: "tap, pan, pinch, rotation, fling, long press, race, manual, simultaneous, force touch unavailable-hardware parity",
+            working: "GestureDetector, Gesture.Tap/Pan/Pinch/Rotation/Fling/LongPress/ForceTouch/Manual/Race/Simultaneous/Exclusive/Hover, ForceTouchGestureHandler unavailable-hardware fallback (children render, forceTouchAvailable false, no force events), simultaneousWithExternalGesture/requireExternalGestureToFail/blocksExternalGesture, ScrollView/FlatList, Switch/RefreshControl, Pressable/Text, Touchables, BaseButton/RawButton/RectButton/BorderlessButton/PureNativeButton, Swipeable, ReanimatedSwipeable, DrawerLayout (the upstream component running on this seam: renderNavigationView, drawerPosition/drawerType/drawerWidth/edgeWidth, openDrawer/closeDrawer, edge-swipe drag, onDrawerOpen/onDrawerClose/onDrawerStateChanged), GestureHandlerRootView, createNativeWrapper, gestureHandlerRootHOC, PointerType/MouseButton/HoverEffect exports, velocity tracking, activeOffsets, multi-tap",
+            missing: "Force Touch recognition is unavailable because browser pointer input has no pressure signal; both public APIs expose the upstream unavailable-hardware behavior instead of inventing force events"
           }
         ]
       },
@@ -2683,7 +2675,7 @@ var init_registry = __esm({
             coverage: 0.95,
             note: "suite-scoped NSUserDefaults-style string storage backed by localStorage or in-memory storage",
             working: "default export, get, set, clear, getMultiple, setMultiple, clearMultiple, getAll, clearAll, setName, getName",
-            missing: "sharing values with real native UserDefaults/app groups outside the sootsim runtime"
+            missing: "sharing values with real native UserDefaults/app groups outside the RNX runtime"
           }
         ]
       },
@@ -14447,14 +14439,14 @@ var init_backend_origin = __esm({
 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 mergeSootSimConfig(base, override) {
-  if (!hasSootSimConfig(base) && !hasSootSimConfig(override)) return void 0;
-  if (!hasSootSimConfig(base)) return override ? { ...override } : void 0;
-  if (!hasSootSimConfig(override)) return base ? { ...base } : void 0;
+function mergeRNXConfig(base, override) {
+  if (!hasRNXConfig(base) && !hasRNXConfig(override)) return void 0;
+  if (!hasRNXConfig(base)) return override ? { ...override } : void 0;
+  if (!hasRNXConfig(override)) return base ? { ...base } : void 0;
   return {
     runtimeVersion: override.runtimeVersion ?? base.runtimeVersion,
     modules: { ...base.modules || {}, ...override.modules || {} },
@@ -14474,20 +14466,20 @@ function mergeSootSimConfig(base, override) {
     initialState: { ...base.initialState || {}, ...override.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();
 }
-var SOOTSIM_CONFIG_QUERY_PARAM;
+var RNX_CONFIG_QUERY_PARAM;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
-    SOOTSIM_CONFIG_QUERY_PARAM = "sootsimConfig";
+    RNX_CONFIG_QUERY_PARAM = "rnxConfig";
   }
 });
 
@@ -15211,10 +15203,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) {
@@ -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();
@@ -15604,13 +15610,17 @@ var init_public_brand = __esm({
 // src/cli-version.ts
 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 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 +15631,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 = {};
@@ -15641,7 +15651,7 @@ __export(home_paths_exports, {
   DAEMON_HEARTBEAT_STALE_MS: () => DAEMON_HEARTBEAT_STALE_MS,
   DAEMON_LOCKFILE: () => DAEMON_LOCKFILE,
   DEV_BRIDGES_DIR: () => DEV_BRIDGES_DIR,
-  SOOTSIM_HOME_ENV: () => SOOTSIM_HOME_ENV,
+  RNX_HOME_ENV: () => RNX_HOME_ENV,
   activeRuntimeDir: () => activeRuntimeDir,
   activeRuntimeFile: () => activeRuntimeFile,
   cacheDir: () => cacheDir,
@@ -15658,7 +15668,7 @@ __export(home_paths_exports, {
   electronDir: () => electronDir,
   electronUserDataDir: () => electronUserDataDir,
   electronVersionDir: () => electronVersionDir,
-  ensureSootsimHome: () => ensureSootsimHome,
+  ensureRnxHome: () => ensureRnxHome,
   isDaemonLockfileFresh: () => isDaemonLockfileFresh,
   isDevBridgeLockfileFresh: () => isDevBridgeLockfileFresh,
   isDevWorkstation: () => isDevWorkstation,
@@ -15675,11 +15685,11 @@ __export(home_paths_exports, {
   readSimulatorDriverPreference: () => readSimulatorDriverPreference,
   removeDaemonLockfile: () => removeDaemonLockfile,
   removeDevBridgeLockfile: () => removeDevBridgeLockfile,
+  rnxHomeDir: () => rnxHomeDir,
   runtimeDir: () => runtimeDir,
   runtimeUpgradeNoticePath: () => runtimeUpgradeNoticePath,
   runtimesDir: () => runtimesDir,
   shouldSkipPersistentDaemon: () => shouldSkipPersistentDaemon,
-  sootsimHomeDir: () => sootsimHomeDir,
   writeActiveRuntime: () => writeActiveRuntime,
   writeDaemonLockfile: () => writeDaemonLockfile,
   writeDevBridgeLockfile: () => writeDevBridgeLockfile,
@@ -15688,10 +15698,10 @@ __export(home_paths_exports, {
   writeRuntimeUpgradeNotice: () => writeRuntimeUpgradeNotice,
   writeSharedConfig: () => writeSharedConfig
 });
-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;
@@ -15701,7 +15711,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;
@@ -15715,7 +15725,7 @@ function shouldSkipPersistentDaemon() {
   return isSootsimDevCheckout() || isDevWorkstation();
 }
 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);
@@ -15724,7 +15734,7 @@ 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");
@@ -15733,28 +15743,28 @@ function electronVersionDir(version) {
   return import_node_path4.default.join(electronDir(), version);
 }
 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 daemonAppDir() {
-  return import_node_path4.default.join(sootsimHomeDir(), "daemon-app");
+  return import_node_path4.default.join(rnxHomeDir(), "daemon-app");
 }
 function daemonAppBundlePath() {
-  return import_node_path4.default.join(daemonAppDir(), "SootSim Daemon.app");
+  return import_node_path4.default.join(daemonAppDir(), "RNX Daemon.app");
 }
 function daemonAppLauncherPath() {
-  return import_node_path4.default.join(daemonAppBundlePath(), "Contents", "MacOS", "sootsim-daemon");
+  return import_node_path4.default.join(daemonAppBundlePath(), "Contents", "MacOS", "rnx-daemon");
 }
 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) {
@@ -15763,11 +15773,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 {
@@ -15775,7 +15785,7 @@ function readSharedConfig() {
   }
 }
 function writeSharedConfig(patch) {
-  ensureSootsimHome();
+  ensureRnxHome();
   const current = readSharedConfig();
   const next = { ...current, ...patch };
   if (patch.settings && typeof patch.settings === "object") {
@@ -15785,9 +15795,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() {
@@ -15829,19 +15839,19 @@ function readOrCreateAnonymousId() {
   return created;
 }
 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 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 {
@@ -15853,24 +15863,24 @@ function consumeRuntimeUpgradeNotice() {
     return null;
   }
 }
-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() {
@@ -15878,17 +15888,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 +15906,7 @@ function readDaemonLockfile() {
       }
       return null;
     } finally {
-      import_node_fs3.default.closeSync(fd);
+      import_node_fs4.default.closeSync(fd);
     }
   } catch {
     return null;
@@ -15916,7 +15926,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 +15935,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 +15946,7 @@ function readDevBridgeLockfiles() {
           lockfiles.push(lockfile);
         }
       } finally {
-        import_node_fs3.default.closeSync(fd);
+        import_node_fs4.default.closeSync(fd);
       }
     } catch {
     }
@@ -15977,7 +15987,7 @@ function readLiveRuntimeVersions() {
   return [...versions].sort();
 }
 function writeDaemonLockfile(data) {
-  ensureSootsimHome();
+  ensureRnxHome();
   const lockfilePath = daemonLockfilePath();
   const existing = readDaemonLockfile();
   if (!existing) {
@@ -15988,28 +15998,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 +16030,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 +16064,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 +16088,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 +16098,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,12 +16112,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();
@@ -16121,7 +16131,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,28 +16145,28 @@ 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, RNX_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";
+    RNX_HOME_ENV = "RNX_HOME";
     ACTIVE_RUNTIME_FILE = "active";
     DAEMON_LOCKFILE = "daemon.json";
     DEV_BRIDGES_DIR = "dev-bridges";
@@ -16174,7 +16184,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 +16213,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 +16227,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 +16300,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 +16314,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 +16325,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 +16338,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 +16373,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 +16423,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 +16498,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 +16518,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 +16547,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 +16566,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 +16584,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");
@@ -16606,7 +16616,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");
@@ -16676,7 +16686,7 @@ var init_runtime_assets = __esm({
 });
 
 // src/runtime-delivery.ts
-var DEFAULT_RUNTIME_CDN_ORIGIN, SOOTSIM_CHANGELOG_URL, SOOTSIM_CHANGELOG_API_URL, SOOTSIM_RUNTIME_PRODUCT, sootsimRuntime;
+var DEFAULT_RUNTIME_CDN_ORIGIN, RNX_CHANGELOG_URL, RNX_CHANGELOG_API_URL, RNX_RUNTIME_PRODUCT, rnxRuntime;
 var init_runtime_delivery = __esm({
   "src/runtime-delivery.ts"() {
     "use strict";
@@ -16684,10 +16694,10 @@ var init_runtime_delivery = __esm({
     init_home_paths();
     init_public_brand();
     DEFAULT_RUNTIME_CDN_ORIGIN = "https://contrast.dev";
-    SOOTSIM_CHANGELOG_URL = `${rnxPublicBrand.origin}/changelog`;
-    SOOTSIM_CHANGELOG_API_URL = "https://contrast.dev/api/changelog/sootsim";
-    SOOTSIM_RUNTIME_PRODUCT = {
-      id: "sootsim",
+    RNX_CHANGELOG_URL = `${rnxPublicBrand.origin}/changelog`;
+    RNX_CHANGELOG_API_URL = "https://contrast.dev/api/changelog/sootsim";
+    RNX_RUNTIME_PRODUCT = {
+      id: "rnx",
       defaultCdnOrigin: DEFAULT_RUNTIME_CDN_ORIGIN,
       manifestPath: "/runtimes/manifest.json",
       tarballPath: (version) => `/runtimes/sootsim-runtime-${version}.tar.gz`,
@@ -16696,10 +16706,10 @@ var init_runtime_delivery = __esm({
       // 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,
@@ -16707,7 +16717,7 @@ var init_runtime_delivery = __esm({
       readActiveRuntime,
       writeActiveRuntime
     };
-    sootsimRuntime = createRuntimeDelivery(SOOTSIM_RUNTIME_PRODUCT);
+    rnxRuntime = createRuntimeDelivery(RNX_RUNTIME_PRODUCT);
   }
 });
 
@@ -16786,7 +16796,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 +16813,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 +16824,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 +17019,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 +17041,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,13 +17075,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;
@@ -17081,7 +17091,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: [] };
       }
     }
   }
@@ -17094,7 +17104,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: [] };
@@ -17103,16 +17113,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\`.`
@@ -17140,8 +17150,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 +17173,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 +17183,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 +17207,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 +17230,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 +17288,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 +17341,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 +17369,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 +17402,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 +17410,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 +17425,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 +17439,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 +17447,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 +17467,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 +17590,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 +17805,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();
@@ -18508,27 +18518,152 @@ var init_open_url = __esm({
   }
 });
 
+// ../contrast-harness/src/planeProtocol.ts
+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;
+  }
+}
+var PLANE_FLAG_READ_ONLY, PLANE_FLAG_BINARY;
+var init_planeProtocol = __esm({
+  "../contrast-harness/src/planeProtocol.ts"() {
+    "use strict";
+    PLANE_FLAG_READ_ONLY = 1;
+    PLANE_FLAG_BINARY = 2;
+  }
+});
+
+// ../contrast-harness/src/projectFileCache.ts
+var init_projectFileCache = __esm({
+  "../contrast-harness/src/projectFileCache.ts"() {
+    "use strict";
+  }
+});
+
+// ../contrast-harness/src/planeClient.ts
+var init_planeClient = __esm({
+  "../contrast-harness/src/planeClient.ts"() {
+    "use strict";
+    init_planeProtocol();
+    init_projectFileCache();
+  }
+});
+
+// ../contrast-harness/src/projectFilePlaneRpc.ts
+var init_projectFilePlaneRpc = __esm({
+  "../contrast-harness/src/projectFilePlaneRpc.ts"() {
+    "use strict";
+    init_planeProtocol();
+  }
+});
+
+// ../contrast-harness/src/planeTransport.browser.ts
+var init_planeTransport_browser = __esm({
+  "../contrast-harness/src/planeTransport.browser.ts"() {
+    "use strict";
+  }
+});
+
+// ../contrast-harness/src/plane.ts
+var init_plane = __esm({
+  "../contrast-harness/src/plane.ts"() {
+    "use strict";
+    init_planeProtocol();
+    init_planeClient();
+    init_projectFilePlaneRpc();
+    init_planeTransport_browser();
+    init_projectFileCache();
+  }
+});
+
 // cli/commands/box/checkout-plane.ts
 function looksBinary(filePath, size) {
   if (size === 0) return false;
   let fd;
   try {
-    fd = import_node_fs9.default.openSync(filePath, "r");
+    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 +18716,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 +18743,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 +18760,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,13 +18768,13 @@ 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, 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_plane();
     init_checkout_plane();
     WS_OPEN2 = 1;
     PlaneNotRegisteredError = class extends Error {
@@ -18731,7 +18866,7 @@ var init_plane_host = __esm({
             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);
@@ -18745,7 +18880,7 @@ var init_plane_host = __esm({
           }
           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;
@@ -18764,11 +18899,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) {
@@ -19540,7 +19675,7 @@ var init_bridge_host = __esm({
               return;
             }
             if (msg.type === "runtime:list") {
-              const versions = sootsimRuntime.listInstalled();
+              const versions = rnxRuntime.listInstalled();
               const active = this.getActiveRuntime();
               const reply = {
                 type: "runtime:list:ok",
@@ -19557,7 +19692,7 @@ var init_bridge_host = __esm({
             }
             if (msg.type === "runtime:use") {
               const version = typeof msg.version === "string" ? msg.version : "";
-              const installed2 = sootsimRuntime.listInstalled();
+              const installed2 = rnxRuntime.listInstalled();
               if (!installed2.includes(version)) {
                 try {
                   ws.send(
@@ -19920,7 +20055,7 @@ var init_bridge_host = __esm({
         this.wsHeartbeatTimer.unref();
         if (this.shouldWriteLockfile) {
           try {
-            ensureSootsimHome();
+            ensureRnxHome();
             const claimed = claimDaemonLockfile(this.buildLockfileSnapshot());
             if (!claimed) {
               throw new Error(
@@ -20050,7 +20185,7 @@ var init_bridge_host = __esm({
         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.
@@ -20160,8 +20295,8 @@ var init_bridge_host = __esm({
       }
       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");
@@ -20178,7 +20313,7 @@ var init_bridge_host = __esm({
             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) {
@@ -21442,7 +21577,7 @@ function getCurrentSimPath() {
     return (0, import_path3.resolve)(process.env[CURRENT_SIM_PATH_ENV]);
   }
   const key = getCliIdentityKey();
-  return (0, import_path3.join)((0, import_os.tmpdir)(), `sootsim-current-sim-${key}.json`);
+  return (0, import_path3.join)((0, import_os.tmpdir)(), `rnx-current-sim-${key}.json`);
 }
 function readCurrentSim() {
   const filepath = getCurrentSimPath();
@@ -21498,7 +21633,7 @@ var init_current_sim = __esm({
     CURRENT_SIM_VERSION = 1;
     CURRENT_SIM_PATH_ENV = "SOOTSIM_CLI_CURRENT_SIM_PATH";
     IDENTITY_ENV_VARS = [
-      "SOOTSIM_CLI_IDENTITY",
+      "RNX_CLI_IDENTITY",
       // explicit override — fastest path, skips all pid lookups
       "TM_SESSION",
       // Team Machine session id; routes prompt-bar followups back to this agent
@@ -21561,7 +21696,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;
@@ -21603,7 +21738,7 @@ function resolveDefaultDevBridgeLockfile() {
   return lockfiles.find((lockfile) => lockfile.bridgePort === DEFAULT_SOOTSIM_BRIDGE_PORT) ?? lockfiles[0];
 }
 function resolveBridgeWorld() {
-  const homeDir = sootsimHomeDir();
+  const homeDir = rnxHomeDir();
   if (resolvedWorld?.homeDir === homeDir) return resolvedWorld.world;
   const world = resolveBridgeWorldFresh();
   resolvedWorld = { homeDir, world };
@@ -21998,11 +22133,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();
@@ -22318,7 +22453,7 @@ function withDefault(index) {
   };
 }
 function writeIndex(index) {
-  ensureSootsimHome();
+  ensureRnxHome();
   const next = withDefault(index);
   const tmp = `${profileIndexPath()}.tmp`;
   import_fs5.default.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}
@@ -22368,7 +22503,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 {
     }
   }
@@ -22377,27 +22512,27 @@ function firstNamedFile(dir, names) {
 function findExpoAppConfig(dir) {
   return firstNamedFile(dir, EXPO_APP_CONFIG_NAMES);
 }
-function findSootSimAppConfig(dir) {
-  return firstNamedFile(dir, SOOTSIM_APP_CONFIG_NAMES);
+function findRNXAppConfig(dir) {
+  return firstNamedFile(dir, RNX_APP_CONFIG_NAMES);
 }
 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"))) {
+  const configPath = findRNXAppConfig(appDir);
+  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, RNX_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",
@@ -22406,11 +22541,11 @@ var init_app_project = __esm({
       "app.config.mjs",
       "app.json"
     ];
-    SOOTSIM_APP_CONFIG_NAMES = [
-      "sootsim.config.ts",
-      "sootsim.config.js",
-      "sootsim.config.mjs",
-      "sootsim.config.cjs"
+    RNX_APP_CONFIG_NAMES = [
+      "rnx.config.ts",
+      "rnx.config.js",
+      "rnx.config.mjs",
+      "rnx.config.cjs"
     ];
   }
 });
@@ -22419,7 +22554,7 @@ var init_app_project = __esm({
 function isOptionalRecord(value) {
   return value === void 0 || value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function isSootSimConfig(value) {
+function isRNXConfig(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
   const runtimeVersion = Reflect.get(value, "runtimeVersion");
   const network = Reflect.get(value, "network");
@@ -22438,7 +22573,7 @@ function resolveConfigReplacementFiles(config, configPath) {
     )
   };
 }
-async function loadSootSimAppConfig(project) {
+async function loadRNXAppConfig(project) {
   if (!project?.configPath) return void 0;
   try {
     const jiti = (0, import_jiti.createJiti)(__sootsim_import_meta_url, {
@@ -22450,7 +22585,7 @@ async function loadSootSimAppConfig(project) {
       }
     });
     const loaded = await jiti.import(project.configPath, { default: true });
-    if (!isSootSimConfig(loaded)) {
+    if (!isRNXConfig(loaded)) {
       throw new Error("the default export must be an rnx config object");
     }
     return resolveConfigReplacementFiles(loaded, project.configPath);
@@ -22459,9 +22594,9 @@ async function loadSootSimAppConfig(project) {
     throw new Error(`could not load ${project.configPath}: ${message}`);
   }
 }
-async function resolveSootSimAppConfig(startDir = process.cwd()) {
+async function resolveRNXAppConfig(startDir = process.cwd()) {
   const project = resolveAppProject(startDir);
-  return { project, config: await loadSootSimAppConfig(project) };
+  return { project, config: await loadRNXAppConfig(project) };
 }
 var import_node_module, import_node_path15, import_jiti, require2;
 var init_app_config = __esm({
@@ -22536,7 +22671,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 +22693,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 +22735,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 +22754,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 +22764,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 +22781,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 +22827,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 +23924,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 +23937,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 +23976,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 +24015,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 = `
@@ -23936,7 +24071,7 @@ function resolveUserDataDir(opts) {
     return playwrightProfileUserDataDir(ensureProfile(opts.profileId).id);
   }
   if (opts.ephemeralProfile) {
-    return (0, import_fs7.mkdtempSync)((0, import_path6.join)((0, import_os2.tmpdir)(), "sootsim-playwright-profile-"));
+    return (0, import_fs7.mkdtempSync)((0, import_path6.join)((0, import_os2.tmpdir)(), "rnx-playwright-profile-"));
   }
   return "";
 }
@@ -23968,7 +24103,7 @@ async function launch2(opts) {
   }
   const errLog = (0, import_path6.join)(
     (0, import_os2.tmpdir)(),
-    `sootsim-playwright-host-${Date.now().toString(36)}-${process.pid}.log`
+    `rnx-playwright-host-${Date.now().toString(36)}-${process.pid}.log`
   );
   const connectAckFile = `${errLog}.connected`;
   const errFd = (0, import_fs7.openSync)(errLog, "a");
@@ -24060,7 +24195,7 @@ const callerUserDataDir = process.env.SOOTSIM_PW_USERDATADIR || '';
 const ownerPid = Number(process.env.SOOTSIM_PW_OWNER_PID || 0);
 const ownerPollMs = Number(process.env.SOOTSIM_PW_OWNER_POLL_MS || 5000);
 // optional CDP port \u2014 exposes Chrome's remote-debugging endpoint so a
-// bridge-driven sim can also be cpu-profiled (sootsim perf cpu --cdp-port).
+// bridge-driven sim can also be cpu-profiled (rnx perf cpu --cdp-port).
 // playwright keeps its own pipe connection; the port is an additional endpoint.
 const cdpPort = process.env.SOOTSIM_PW_CDP_PORT || '';
 // extra chromium launch args, space-separated. a linux GPU runner injects
@@ -24104,7 +24239,7 @@ const { join } = require('path');
 //
 // the prior approach was \`pgrep -f ms-playwright/[c]hromium\`. it never matched
 // system Chrome, so the reaper was a no-op in the common case and every
-// aborted/closed \`sootsim open\` leaked a renderer + gpu helper burning 100%+
+// aborted/closed \`rnx open\` leaked a renderer + gpu helper burning 100%+
 // CPU until manually killed (multiple incidents 2026-06).
 //
 // fix: identify our chrome tree by its UNIQUE user-data-dir. every helper a
@@ -24117,13 +24252,13 @@ const reapEnabled = process.platform !== 'win32';
 let profileDir = callerUserDataDir;
 let ephemeralProfile = false;
 if (!profileDir) {
-  profileDir = mkdtempSync(join(tmpdir(), 'sootsim-playwright-host-'));
+  profileDir = mkdtempSync(join(tmpdir(), 'rnx-playwright-host-'));
   ephemeralProfile = true;
 }
 // browser HTTP caches are acceleration data, not profile identity. give each
 // host a bounded temporary cache so persistent named profiles retain cookies
 // and storage without multiplying a private cache for every profile.
-const diskCacheDir = mkdtempSync(join(tmpdir(), 'sootsim-playwright-cache-'));
+const diskCacheDir = mkdtempSync(join(tmpdir(), 'rnx-playwright-cache-'));
 const chromePidsByProfile = () => {
   if (!reapEnabled) return [];
   try {
@@ -24294,7 +24429,7 @@ const cleanupProfile = () => {
   // through shutdown(); the exit hook (sync sweep) still reaps the tree.
   process.on('exit', () => { reapChrome(); cleanupProfile(); });
   // owner-liveness watchdog \u2014 the load-bearing fix for leaked Chrome hosts.
-  // we are spawned detached + unref'd so \`sootsim open\` returns immediately,
+  // we are spawned detached + unref'd so \`rnx open\` returns immediately,
   // which means nothing in the OS process tree ties Chrome's lifetime to the
   // session that asked for it. once the sim connects, the connect-timeout
   // safety net is cleared, so absent an explicit \`sootsim close\` (or the
@@ -24323,7 +24458,7 @@ const cleanupProfile = () => {
   // com.google.chrome.for.testing identity cannot intercept open/quit events for
   // the user's com.google.Chrome browser. CI may use chromium_headless_shell;
   // local rendering fails closed because that shell has no GPU and silently
-  // chooses SwiftShader. NOTE: this is NOT enough to make \`sootsim perf cpu\`
+  // chooses SwiftShader. NOTE: this is NOT enough to make \`rnx perf cpu\`
   // work \u2014 that profiles the tenant *worker*, and the JS Self-Profiler API
   // cannot be constructed in a dedicated worker (see
   // worker-handlers/cpu-profile.ts). cpu-profile needs a CDP-based profiler
@@ -24589,7 +24724,7 @@ var init_run_rnx = __esm({
 
 // cli/commands/inspect/env.ts
 function isAgentEnv() {
-  if (process.env.SOOTSIM_AGENT === "0") return false;
+  if (process.env.RNX_AGENT === "0") return false;
   for (const name2 of AGENT_ENV_VARS) {
     const v = process.env[name2];
     if (v && v.trim() && v !== "0") return true;
@@ -24601,7 +24736,7 @@ var init_env = __esm({
   "cli/commands/inspect/env.ts"() {
     "use strict";
     AGENT_ENV_VARS = [
-      "SOOTSIM_AGENT",
+      "RNX_AGENT",
       "TM_SESSION",
       "CLAUDECODE",
       "CLAUDE_CODE_ENTRYPOINT",
@@ -24625,7 +24760,7 @@ function isChangelogEntry(value) {
 }
 async function fetchRuntimeReleaseNotes(version, fetchImpl = fetch) {
   try {
-    const url = new URL(SOOTSIM_CHANGELOG_API_URL);
+    const url = new URL(RNX_CHANGELOG_API_URL);
     url.searchParams.set("version", version);
     const response = await fetchImpl(url, {
       headers: { accept: "application/json" },
@@ -24653,7 +24788,7 @@ function formatRuntimeReleaseNotes(version, entry) {
       }
     }
   }
-  lines.push(`  full changelog: ${SOOTSIM_CHANGELOG_URL}`);
+  lines.push(`  full changelog: ${RNX_CHANGELOG_URL}`);
   return lines.join("\n");
 }
 var init_runtime_notes = __esm({
@@ -24695,7 +24830,7 @@ async function runRuntime(args, opts = {}) {
 }
 function printHelp() {
   console.log(`
-rnx runtime \u2014 manage engine runtimes under ~/.sootsim/runtimes/
+rnx runtime \u2014 manage engine runtimes under ~/.rnx/runtimes/
 
 usage:
   rnx runtime install [version]   install a version (default: channel latest)
@@ -24711,7 +24846,7 @@ flags:
   --set-active=false  do not switch active runtime after install
 
 environment:
-  SOOTSIM_CDN_ORIGIN  override the CDN base URL (default: ${DEFAULT_RUNTIME_CDN_ORIGIN})
+  RNX_CDN_ORIGIN  override the CDN base URL (default: ${DEFAULT_RUNTIME_CDN_ORIGIN})
 
 examples:
   rnx runtime install
@@ -24726,11 +24861,11 @@ async function runtimeInstall(args, opts) {
   const channel = flags.channel ?? opts.channel ?? "stable";
   const force = flags.force === true;
   const setActive = flags.setActive !== false;
-  ensureSootsimHome();
+  ensureRnxHome();
   console.log(`rnx runtime install`);
-  console.log(`  cdn:     ${sootsimRuntime.resolveCdnOrigin()}`);
+  console.log(`  cdn:     ${rnxRuntime.resolveCdnOrigin()}`);
   try {
-    const result = await sootsimRuntime.install({
+    const result = await rnxRuntime.install({
       version: versionArg,
       channel,
       force,
@@ -24807,8 +24942,8 @@ async function tellDaemonRuntimeChanged(version) {
   });
 }
 async function runtimeList(_args) {
-  ensureSootsimHome();
-  const installed2 = sootsimRuntime.listInstalled();
+  ensureRnxHome();
+  const installed2 = rnxRuntime.listInstalled();
   const active = readActiveRuntime();
   console.log(`installed:`);
   if (installed2.length === 0) {
@@ -24820,7 +24955,7 @@ async function runtimeList(_args) {
     }
   }
   try {
-    const manifest = await sootsimRuntime.fetchManifest();
+    const manifest = await rnxRuntime.fetchManifest();
     console.log(`available (latest per channel):`);
     for (const [name2, ch] of Object.entries(manifest.channels)) {
       console.log(`  ${name2.padEnd(8)} ${ch.latest}`);
@@ -24840,7 +24975,7 @@ async function runtimeUse(args) {
     console.error(`  usage: rnx runtime use <version>`);
     rnxExit(1);
   }
-  const installed2 = sootsimRuntime.listInstalled();
+  const installed2 = rnxRuntime.listInstalled();
   if (!installed2.includes(version)) {
     console.error(`  version ${version} is not installed`);
     console.error(`  installed: ${installed2.join(", ") || "(none)"}`);
@@ -24888,11 +25023,11 @@ async function runtimeNotes(args) {
     console.error(`  usage: rnx runtime notes`);
     rnxExit(1);
   }
-  const { config } = await resolveSootSimAppConfig();
+  const { config } = await resolveRNXAppConfig();
   const version = config?.runtimeVersion ?? readActiveRuntime();
   if (!version) {
     console.log(`  no active runtime`);
-    console.log(`  release notes: ${SOOTSIM_CHANGELOG_URL}`);
+    console.log(`  release notes: ${RNX_CHANGELOG_URL}`);
     return;
   }
   console.log(formatRuntimeReleaseNotes(version, await fetchRuntimeReleaseNotes(version)));
@@ -24954,6 +25089,7 @@ __export(control_exports, {
   planBulkCloseTargets: () => planBulkCloseTargets,
   playwrightHostPidForSim: () => playwrightHostPidForSim,
   printConnectedSims: () => printConnectedSims,
+  printOpenedSim: () => printOpenedSim,
   resolveBundleTarget: () => resolveBundleTarget,
   resolveDefaultShellBaseUrl: () => resolveDefaultShellBaseUrl,
   resolveDriverConnectWaitOptions: () => resolveDriverConnectWaitOptions,
@@ -25057,19 +25193,19 @@ function assertExplicitBridgeLock(preferredPort, explicitPort, lock) {
     return;
   }
   throw new Error(
-    `${rnxPublicBrand.commandName} open: requested bridge port ${preferredPort}, but the active daemon owns port ${lock.bridgePort}. explicit --port never selects another bridge; stop that daemon or use an isolated SOOTSIM_HOME.`
+    `${rnxPublicBrand.commandName} open: requested bridge port ${preferredPort}, but the active daemon owns port ${lock.bridgePort}. explicit --port never selects another bridge; stop that daemon or use an isolated RNX_HOME.`
   );
 }
 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 +25374,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,9 +25405,9 @@ 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({
+  const result = await rnxRuntime.install({
     version,
     setActive: false,
     protectVersions: readLiveRuntimeVersions()
@@ -25629,7 +25765,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 +25779,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 +25874,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(RNX_CONFIG_QUERY_PARAM)) {
+        parsed.searchParams.set(RNX_CONFIG_QUERY_PARAM, "[redacted]");
+        changed = true;
       }
+      const bundle = parsed.searchParams.get("bundle");
+      if (bundle) {
+        try {
+          const parsedBundle = new URL(bundle);
+          if (parsedBundle.searchParams.has(RNX_CONFIG_QUERY_PARAM)) {
+            parsedBundle.searchParams.set(RNX_CONFIG_QUERY_PARAM, "[redacted]");
+            parsed.searchParams.set("bundle", parsedBundle.toString());
+            changed = true;
+          }
+        } catch {
+        }
+      }
+      if (changed) return parsed.toString();
     } catch {
     }
     return value;
@@ -25950,10 +26100,10 @@ async function runOpenCommand(args, opts = {}) {
   }
   const resolvedBundle = shouldResolveBundleTargetInCli(target) ? await resolveConnectionInputForCli(target) : void 0;
   const project = await resolveOpenAppProject(resolvedBundle);
-  const appConfig = await loadSootSimAppConfig(project);
+  const appConfig = await loadRNXAppConfig(project);
   const configuredRuntimeVersion = appConfig?.runtimeVersion;
-  const runtimeConfig = mergeSootSimConfig(
-    mergeSootSimConfig(
+  const runtimeConfig = mergeRNXConfig(
+    mergeRNXConfig(
       appConfig ? { ...appConfig, runtimeVersion: void 0 } : void 0,
       opts.runtimeConfig
     ),
@@ -26042,7 +26192,7 @@ async function runOpenCommand(args, opts = {}) {
         if (!targetSim && parsed.simIdSource !== "flag") {
           targetShellUrl = await buildShellUrl(
             target,
-            applySootSimConfigToUrl(baseUrl, runtimeConfig),
+            applyRNXConfigToUrl(baseUrl, runtimeConfig),
             buildShellUrlOpts
           );
           const normalizedTarget = new URL(targetShellUrl);
@@ -26071,7 +26221,7 @@ async function runOpenCommand(args, opts = {}) {
           const resolvedBaseUrl = hasExplicitBaseUrl || looksLikeSootsimUrl(target) ? baseUrl : deriveCurrentSimBaseUrl(targetSim, baseUrl);
           const shellUrl = targetShellUrl ?? await buildShellUrl(
             target,
-            applySootSimConfigToUrl(resolvedBaseUrl, runtimeConfig),
+            applyRNXConfigToUrl(resolvedBaseUrl, runtimeConfig),
             buildShellUrlOpts
           );
           bridge.send({
@@ -26108,7 +26258,7 @@ async function runOpenCommand(args, opts = {}) {
         const resolvedBaseUrl = hasExplicitBaseUrl || looksLikeSootsimUrl(target) ? baseUrl : deriveCurrentSimBaseUrl(targetSim, baseUrl);
         const shellUrl = targetShellUrl ?? await buildShellUrl(
           target,
-          applySootSimConfigToUrl(resolvedBaseUrl, runtimeConfig),
+          applyRNXConfigToUrl(resolvedBaseUrl, runtimeConfig),
           buildShellUrlOpts
         );
         printOpenedSim(shellUrl, { ...targetSim, url: shellUrl }, "current sim", quiet);
@@ -26119,7 +26269,7 @@ async function runOpenCommand(args, opts = {}) {
       bridge.close();
     }
   }
-  const configuredBaseUrl = applySootSimConfigToUrl(baseUrl, runtimeConfig);
+  const configuredBaseUrl = applyRNXConfigToUrl(baseUrl, runtimeConfig);
   const token = `cli-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
   const openUrl2 = await buildOpenUrl(target, configuredBaseUrl, token, buildShellUrlOpts);
   const ownerPid = getStableOwnerPid();
@@ -26215,7 +26365,7 @@ async function runUseLikeCommand(args, opts = {}) {
             `  refused: ${target.id} is leased by ${target.lockedBy} (${secs}s)`
           );
           console.error(
-            `  \`sootsim use ${target.id} --force\` to take it, or \`rnx open --new\` for a fresh sim`
+            `  \`rnx use ${target.id} --force\` to take it, or \`rnx open --new\` for a fresh sim`
           );
           rnxExit(1);
         }
@@ -26452,12 +26602,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 +27527,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;
@@ -27432,14 +27582,12 @@ function resolveGitHubActionsAuth() {
   };
 }
 function isCliApiKeySecret(secret) {
-  return secret.startsWith("sk_rnx_") || secret.startsWith("sk_sootsim_");
+  return secret.startsWith("sk_rnx_");
 }
 function readApiKeyFromEnv() {
-  for (const envName of ["RNX_API_KEY", "SOOTSIM_API_KEY"]) {
-    const secret = process.env[envName]?.trim();
-    if (secret && isCliApiKeySecret(secret)) return { secret, envName };
-  }
-  return null;
+  const envName = "RNX_API_KEY";
+  const secret = process.env[envName]?.trim();
+  return secret && isCliApiKeySecret(secret) ? { secret, envName } : null;
 }
 function resolveCliAuth() {
   const envKey = readApiKeyFromEnv();
@@ -27483,7 +27631,7 @@ var init_run_registry = __esm({
 // cli/commands/upload.ts
 async function resolveDefaultUploadOrigin(explicitOrigin) {
   if (explicitOrigin) return explicitOrigin;
-  if (process.env.SOOTSIM_UPLOAD_ORIGIN) return process.env.SOOTSIM_UPLOAD_ORIGIN;
+  if (process.env.RNX_UPLOAD_ORIGIN) return process.env.RNX_UPLOAD_ORIGIN;
   return REMOTE_DEFAULT_ORIGIN;
 }
 var import_compress, import_compress_node, import_presigned_upload, import_trace, REMOTE_DEFAULT_ORIGIN, REMOTE_DEFAULT_PUBLIC_PREVIEW_ORIGIN;
@@ -27502,8 +27650,8 @@ var init_upload = __esm({
     init_run_registry();
     init_run_rnx();
     init_ws_bridge();
-    REMOTE_DEFAULT_ORIGIN = process.env.SOOTSIM_UPLOAD_ORIGIN || "https://contrast.dev";
-    REMOTE_DEFAULT_PUBLIC_PREVIEW_ORIGIN = process.env.SOOTSIM_PREVIEW_ORIGIN || rnxPublicBrand.origin;
+    REMOTE_DEFAULT_ORIGIN = process.env.RNX_UPLOAD_ORIGIN || "https://contrast.dev";
+    REMOTE_DEFAULT_PUBLIC_PREVIEW_ORIGIN = process.env.RNX_PREVIEW_ORIGIN || rnxPublicBrand.origin;
   }
 });
 
@@ -27921,7 +28069,7 @@ var init_bridge_flow_runner = __esm({
         const extension = videoMime.includes("mp4") ? "mp4" : "webm";
         const outputPath = path18.join(
           this.opts.recordingOutputDir,
-          `sootsim-${Date.now()}.${extension}`
+          `rnx-${Date.now()}.${extension}`
         );
         fs18.writeFileSync(outputPath, Buffer.concat(chunks));
         return outputPath;
@@ -29967,9 +30115,9 @@ var skillRegistry = {
       this.register(skill7);
     }
   },
-  // load skills from a project manifest (sootsim-skills.json)
+  // load skills from a project manifest (rnx-skills.json)
   async loadFromManifest(projectDir) {
-    const manifestPath = path19.join(projectDir, "sootsim-skills.json");
+    const manifestPath = path19.join(projectDir, "rnx-skills.json");
     if (!fs19.existsSync(manifestPath)) return;
     try {
       const manifest = JSON.parse(fs19.readFileSync(manifestPath, "utf8"));