peachsim 0.1.629 → 0.1.631

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

@@ -1,4 +1,4 @@
-/*! rnx v0.1.629 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.631 | (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;
@@ -120,23 +120,6 @@ var init_optional_demo_registry = __esm({
   }
 });
 
-// src/public-brand.ts
-var name, peachPublicBrand, rnxPublicBrand;
-var init_public_brand = __esm({
-  "src/public-brand.ts"() {
-    "use strict";
-    name = "Peach";
-    peachPublicBrand = Object.freeze({
-      name,
-      packageName: "peachsim",
-      commandName: "peach",
-      domain: "peachsim.com",
-      origin: "https://peachsim.com"
-    });
-    rnxPublicBrand = peachPublicBrand;
-  }
-});
-
 // src/home-paths.ts
 function rnxHomeDir() {
   const override = process.env[PEACH_HOME_ENV];
@@ -151,7 +134,7 @@ function isSootsimDevCheckout() {
   const argv1 = process.argv[1];
   if (!argv1) return false;
   try {
-    const real = import_node_fs4.default.realpathSync(argv1);
+    const real = import_node_fs3.default.realpathSync(argv1);
     return real.includes(`${import_node_path4.default.sep}packages${import_node_path4.default.sep}peachsim${import_node_path4.default.sep}`);
   } catch {
     return false;
@@ -198,7 +181,7 @@ function configFilePath() {
 }
 function readSharedConfig() {
   try {
-    const raw = import_node_fs4.default.readFileSync(configFilePath(), "utf8");
+    const raw = import_node_fs3.default.readFileSync(configFilePath(), "utf8");
     const parsed = JSON.parse(raw);
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
@@ -216,9 +199,9 @@ function writeSharedConfig(patch) {
     };
   }
   const tmp = `${configFilePath()}.tmp`;
-  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}
+  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}
 `, "utf8");
-  import_node_fs4.default.renameSync(tmp, configFilePath());
+  import_node_fs3.default.renameSync(tmp, configFilePath());
   return next;
 }
 function runtimeUpgradeNoticePath() {
@@ -227,28 +210,28 @@ function runtimeUpgradeNoticePath() {
 function writeRuntimeUpgradeNotice(notice) {
   ensureRnxHome();
   const tmp = `${runtimeUpgradeNoticePath()}.tmp`;
-  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(notice)}
+  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(notice)}
 `, "utf8");
-  import_node_fs4.default.renameSync(tmp, runtimeUpgradeNoticePath());
+  import_node_fs3.default.renameSync(tmp, runtimeUpgradeNoticePath());
 }
 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 });
+  import_node_fs3.default.mkdirSync(rnxHomeDir(), { 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 readActiveRuntime() {
   try {
-    const value = import_node_fs4.default.readFileSync(activeRuntimeFile(), "utf8").trim();
+    const value = import_node_fs3.default.readFileSync(activeRuntimeFile(), "utf8").trim();
     return value.length > 0 ? value : null;
   } catch {
     return null;
   }
 }
 function writeActiveRuntime(version) {
-  import_node_fs4.default.mkdirSync(runtimesDir(), { recursive: true });
-  import_node_fs4.default.writeFileSync(activeRuntimeFile(), `${version}
+  import_node_fs3.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_node_fs3.default.writeFileSync(activeRuntimeFile(), `${version}
 `, "utf8");
 }
 function activeRuntimeDir() {
@@ -256,17 +239,17 @@ function activeRuntimeDir() {
   if (!version) return null;
   const dir = runtimeDir(version);
   try {
-    if (import_node_fs4.default.statSync(dir).isDirectory()) return dir;
+    if (import_node_fs3.default.statSync(dir).isDirectory()) return dir;
   } catch {
   }
   return null;
 }
 function readDaemonLockfile() {
   try {
-    const fd = import_node_fs4.default.openSync(daemonLockfilePath(), "r");
+    const fd = import_node_fs3.default.openSync(daemonLockfilePath(), "r");
     try {
       const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES);
-      const bytesRead = import_node_fs4.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
+      const bytesRead = import_node_fs3.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"))) {
@@ -274,7 +257,7 @@ function readDaemonLockfile() {
       }
       return null;
     } finally {
-      import_node_fs4.default.closeSync(fd);
+      import_node_fs3.default.closeSync(fd);
     }
   } catch {
     return null;
@@ -313,28 +296,28 @@ function writeDaemonLockfile(data) {
     throw new Error("refusing to overwrite another peach daemon lockfile");
   }
   const tmp = `${lockfilePath}.${data.pid}.${(0, import_node_crypto.randomUUID)()}.tmp`;
-  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
     const current = readDaemonLockfile();
     if (!current || !sameDaemonOwner(current, data)) {
       throw new Error("peach daemon lock ownership changed during heartbeat");
     }
-    import_node_fs4.default.renameSync(tmp, lockfilePath);
+    import_node_fs3.default.renameSync(tmp, lockfilePath);
   } finally {
     try {
-      import_node_fs4.default.unlinkSync(tmp);
+      import_node_fs3.default.unlinkSync(tmp);
     } catch {
     }
   }
 }
 function writeDevBridgeLockfile(data) {
-  import_node_fs4.default.mkdirSync(devBridgesDir(), { recursive: true });
+  import_node_fs3.default.mkdirSync(devBridgesDir(), { recursive: true });
   const lockfilePath = devBridgeLockfilePath(data.bridgePort);
   const tmp = `${lockfilePath}.${data.pid}.tmp`;
-  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
 `, "utf8");
-  import_node_fs4.default.renameSync(tmp, lockfilePath);
+  import_node_fs3.default.renameSync(tmp, lockfilePath);
 }
 function sameDaemonOwner(left, right) {
   return left.pid === right.pid && left.startedAt === right.startedAt;
@@ -345,17 +328,17 @@ function isAlreadyExists(error) {
 function createDaemonLockfileExclusive(data) {
   const lockfilePath = daemonLockfilePath();
   const tmp = `${lockfilePath}.${data.pid}.${(0, import_node_crypto.randomUUID)()}.claim`;
-  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
-    import_node_fs4.default.linkSync(tmp, lockfilePath);
+    import_node_fs3.default.linkSync(tmp, lockfilePath);
     return true;
   } catch (error) {
     if (isAlreadyExists(error)) return false;
     throw error;
   } finally {
     try {
-      import_node_fs4.default.unlinkSync(tmp);
+      import_node_fs3.default.unlinkSync(tmp);
     } catch {
     }
   }
@@ -379,7 +362,7 @@ function parseDaemonClaim(raw) {
 }
 function readDaemonClaim() {
   try {
-    return parseDaemonClaim(import_node_fs4.default.readFileSync(daemonClaimPath(), "utf8"));
+    return parseDaemonClaim(import_node_fs3.default.readFileSync(daemonClaimPath(), "utf8"));
   } catch {
     return null;
   }
@@ -403,7 +386,7 @@ function acquireDaemonClaim(data) {
 `;
   for (let attempt = 0; attempt < 8; attempt++) {
     try {
-      import_node_fs4.default.writeFileSync(daemonClaimPath(), serialized, { encoding: "utf8", flag: "wx" });
+      import_node_fs3.default.writeFileSync(daemonClaimPath(), serialized, { encoding: "utf8", flag: "wx" });
       return true;
     } catch (error) {
       if (!isAlreadyExists(error)) throw error;
@@ -413,11 +396,11 @@ function acquireDaemonClaim(data) {
     if (existing && isDaemonClaimFresh(existing)) return false;
     let before;
     try {
-      before = import_node_fs4.default.readFileSync(daemonClaimPath(), "utf8");
+      before = import_node_fs3.default.readFileSync(daemonClaimPath(), "utf8");
       const latest = parseDaemonClaim(before);
       if (latest && isDaemonClaimFresh(latest)) return false;
-      if (import_node_fs4.default.readFileSync(daemonClaimPath(), "utf8") !== before) continue;
-      import_node_fs4.default.unlinkSync(daemonClaimPath());
+      if (import_node_fs3.default.readFileSync(daemonClaimPath(), "utf8") !== before) continue;
+      import_node_fs3.default.unlinkSync(daemonClaimPath());
     } catch {
     }
   }
@@ -427,7 +410,7 @@ function releaseDaemonClaim(owner) {
   try {
     const claim = readDaemonClaim();
     if (!claim || !sameDaemonOwner(claim, owner)) return;
-    import_node_fs4.default.unlinkSync(daemonClaimPath());
+    import_node_fs3.default.unlinkSync(daemonClaimPath());
   } catch {
   }
 }
@@ -446,7 +429,7 @@ function claimDaemonLockfile(data) {
       if (!latest || !sameDaemonOwner(latest, existing)) return false;
       if (isDaemonLockfileFresh(latest)) return false;
       try {
-        import_node_fs4.default.unlinkSync(daemonLockfilePath());
+        import_node_fs3.default.unlinkSync(daemonLockfilePath());
       } catch {
         return false;
       }
@@ -460,25 +443,25 @@ function removeDaemonLockfile(owner) {
   try {
     const lockfile = readDaemonLockfile();
     if (!lockfile || !sameDaemonOwner(lockfile, owner)) return;
-    import_node_fs4.default.unlinkSync(daemonLockfilePath());
+    import_node_fs3.default.unlinkSync(daemonLockfilePath());
   } catch {
   }
 }
 function removeDevBridgeLockfile(owner) {
   try {
     const lockfilePath = devBridgeLockfilePath(owner.bridgePort);
-    const lockfile = parseDevBridgeLockfile(import_node_fs4.default.readFileSync(lockfilePath, "utf8"));
+    const lockfile = parseDevBridgeLockfile(import_node_fs3.default.readFileSync(lockfilePath, "utf8"));
     if (lockfile?.pid !== owner.pid || lockfile.startedAt !== owner.startedAt) return;
-    import_node_fs4.default.unlinkSync(lockfilePath);
+    import_node_fs3.default.unlinkSync(lockfilePath);
   } catch {
   }
 }
-var import_node_crypto, import_node_fs4, import_node_os, import_node_path4, PEACH_HOME_ENV, ACTIVE_RUNTIME_FILE, DAEMON_LOCKFILE, DEV_BRIDGES_DIR, CONFIG_FILE, DAEMON_HEARTBEAT_STALE_MS, DAEMON_LOCKFILE_MAX_BYTES, DAEMON_CLAIM_STALE_MS;
+var import_node_crypto, import_node_fs3, import_node_os, import_node_path4, PEACH_HOME_ENV, ACTIVE_RUNTIME_FILE, DAEMON_LOCKFILE, DEV_BRIDGES_DIR, CONFIG_FILE, DAEMON_HEARTBEAT_STALE_MS, 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_fs4 = __toESM(require("node:fs"), 1);
+    import_node_fs3 = __toESM(require("node:fs"), 1);
     import_node_os = require("node:os");
     import_node_path4 = __toESM(require("node:path"), 1);
     PEACH_HOME_ENV = "PEACH_HOME";
@@ -492,6 +475,23 @@ var init_home_paths = __esm({
   }
 });
 
+// src/public-brand.ts
+var name, peachPublicBrand, rnxPublicBrand;
+var init_public_brand = __esm({
+  "src/public-brand.ts"() {
+    "use strict";
+    name = "Peach";
+    peachPublicBrand = Object.freeze({
+      name,
+      packageName: "peachsim",
+      commandName: "peach",
+      domain: "peachsim.com",
+      origin: "https://peachsim.com"
+    });
+    rnxPublicBrand = peachPublicBrand;
+  }
+});
+
 // src/auth/shared-session.ts
 function sharedDesktopAuthAccounts(user) {
   return [
@@ -502,14 +502,14 @@ function sharedDesktopAuthAccounts(user) {
 function getBaseDir() {
   const explicit = process.env[SESSION_FILE_ENV];
   if (explicit?.trim()) {
-    return (0, import_node_path14.dirname)((0, import_node_path14.resolve)(explicit));
+    return (0, import_node_path15.dirname)((0, import_node_path15.resolve)(explicit));
   }
   return electronUserDataDir();
 }
 function getSharedDesktopAuthFilePath() {
   const explicit = process.env[SESSION_FILE_ENV];
-  if (explicit?.trim()) return (0, import_node_path14.resolve)(explicit);
-  return (0, import_node_path14.join)(getBaseDir(), "desktop-auth.json");
+  if (explicit?.trim()) return (0, import_node_path15.resolve)(explicit);
+  return (0, import_node_path15.join)(getBaseDir(), "desktop-auth.json");
 }
 function normalizeUser(input) {
   if (!input || typeof input !== "object") return null;
@@ -559,26 +559,26 @@ function normalizeSession(input) {
 }
 function readSharedDesktopAuthSession() {
   const filepath = getSharedDesktopAuthFilePath();
-  if (!(0, import_node_fs13.existsSync)(filepath)) return null;
+  if (!(0, import_node_fs14.existsSync)(filepath)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs13.readFileSync)(filepath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs14.readFileSync)(filepath, "utf8"));
     const normalized = normalizeSession(parsed);
     if (!normalized) {
-      (0, import_node_fs13.rmSync)(filepath, { force: true });
+      (0, import_node_fs14.rmSync)(filepath, { force: true });
       return null;
     }
     return normalized;
   } catch {
-    (0, import_node_fs13.rmSync)(filepath, { force: true });
+    (0, import_node_fs14.rmSync)(filepath, { force: true });
     return null;
   }
 }
-var import_node_fs13, import_node_path14, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
+var import_node_fs14, import_node_path15, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
 var init_shared_session = __esm({
   "src/auth/shared-session.ts"() {
     "use strict";
-    import_node_fs13 = require("node:fs");
-    import_node_path14 = require("node:path");
+    import_node_fs14 = require("node:fs");
+    import_node_path15 = require("node:path");
     init_home_paths();
     SESSION_VERSION = 1;
     SESSION_FILE_ENV = "SOOTSIM_SHARED_AUTH_FILE";
@@ -2660,7 +2660,9 @@ async function minify(code, sourceLine, options, withMap) {
   }
   const map = withMap && typeof result.map === "string" ? result.map : null;
   if (withMap && map === null) {
-    throw new Error(`peach Cloud got no source map for the statement at line ${sourceLine}`);
+    throw new Error(
+      `peach Cloud got no source map for the statement at line ${sourceLine}`
+    );
   }
   return { code: result.code.trimEnd(), map, sourceLine };
 }
@@ -2724,8 +2726,9 @@ async function readOrInferModuleIdentity(bundle, mode, inferModuleIdentity) {
 }
 async function buildRnxCloudArtifact(bundle, options = {}) {
   const mode = options.mode ?? "production";
+  const nativeIdentity = (0, import_native_app_identity.detachNativeAppIdentityFooter)(bundle);
   const identity = await readOrInferModuleIdentity(
-    bundle,
+    nativeIdentity.source,
     mode,
     options.inferModuleIdentity
   );
@@ -2751,7 +2754,7 @@ async function buildRnxCloudArtifact(bundle, options = {}) {
     })
   ]);
   const body = pieces.map((piece) => piece.code).join("\n");
-  const code = body + (0, import_metro_production_bundle.createRNXMetroModuleIdentityFooter)({
+  const code = body + (nativeIdentity.identity ? (0, import_native_app_identity.createNativeAppIdentityFooter)(nativeIdentity.identity) : "") + (0, import_metro_production_bundle.createRNXMetroModuleIdentityFooter)({
     version: identity.version,
     identitySource: identity.identitySource,
     modulePaths: identity.modulePaths,
@@ -2814,11 +2817,12 @@ async function buildRnxCloudArtifact(bundle, options = {}) {
     }
   };
 }
-var import_metro_production_bundle, import_terser, MODULE_PATHS_REQUIRED, SOURCE_MAP_REQUIRED, MINIFY_OPTIONS;
+var import_metro_production_bundle, import_native_app_identity, import_terser, MODULE_PATHS_REQUIRED, SOURCE_MAP_REQUIRED, MINIFY_OPTIONS;
 var init_metroCloudArtifact = __esm({
   "../contrast-bundler/src/metroCloudArtifact.ts"() {
     "use strict";
     import_metro_production_bundle = require("peachsim/metro-production-bundle");
+    import_native_app_identity = require("peachsim/native-app-identity");
     import_terser = require("terser");
     init_metroAssetArtifact();
     init_metroDebugSourceMap();
@@ -3047,6 +3051,12 @@ var init_stub_manifest = __esm({
         runtimeTier: "core",
         buildResolvers: ["vite", "dep-prebundle"]
       },
+      vendorEventEmitter: {
+        specifier: "react-native/Libraries/vendor/emitter/EventEmitter",
+        stubFile: "rn-libraries/EventEmitter.ts",
+        runtimeTier: "core",
+        buildResolvers: ["vite", "dep-prebundle"]
+      },
       rctDeviceEventEmitter: {
         specifier: "react-native/Libraries/EventEmitter/RCTDeviceEventEmitter",
         stubFile: "rn-libraries/RCTDeviceEventEmitter.ts",
@@ -3939,39 +3949,82 @@ function detectFramework(deps) {
   return "unknown";
 }
 function detectProject(dir) {
-  const pkgPath = (0, import_path2.join)(dir, "package.json");
-  if (!(0, import_fs2.existsSync)(pkgPath)) return null;
-  let pkg;
-  try {
-    pkg = JSON.parse((0, import_fs2.readFileSync)(pkgPath, "utf8"));
-  } catch {
-    return null;
-  }
+  const pkgPath = (0, import_node_path16.join)(dir, "package.json");
+  if (!(0, import_node_fs15.existsSync)(pkgPath)) return null;
+  const pkg = readProjectManifest(dir);
+  if (!pkg) return null;
   const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const devCommand = metadataValue(
+    metadataValue(readProjectJson(pkgPath), "scripts"),
+    "dev"
+  );
   const framework = detectFramework(deps);
   if (framework === "unknown") return null;
   return {
     dir,
-    name: pkg.name || (0, import_path2.basename)(dir),
+    name: pkg.name || (0, import_node_path16.basename)(dir),
     framework,
     // a config file is a config file whatever module system it declares. real
     // apps write .cjs as often as .js, and missing one reads as "this project
     // has no bundler config" and sends the user to create a second one.
     hasViteConfig: CONFIG_EXTENSIONS.some(
-      (ext) => (0, import_fs2.existsSync)((0, import_path2.join)(dir, `vite.config.${ext}`))
+      (ext) => (0, import_node_fs15.existsSync)((0, import_node_path16.join)(dir, `vite.config.${ext}`))
     ),
     hasMetroConfig: CONFIG_EXTENSIONS.some(
-      (ext) => (0, import_fs2.existsSync)((0, import_path2.join)(dir, `metro.config.${ext}`))
+      (ext) => (0, import_node_fs15.existsSync)((0, import_node_path16.join)(dir, `metro.config.${ext}`))
     ),
-    devCommand: pkg.scripts?.dev || null
+    devCommand: typeof devCommand === "string" ? devCommand : null
   };
 }
-var import_fs2, import_path2, CONFIG_EXTENSIONS;
+function readProjectMetadata(path12) {
+  try {
+    const info = (0, import_node_fs15.lstatSync)(path12);
+    if (!info.isFile() || info.size > 4 * 1024 * 1024) return null;
+    return (0, import_node_fs15.readFileSync)(path12, "utf8");
+  } catch {
+    return null;
+  }
+}
+function metadataValue(value, key) {
+  if (!value || typeof value !== "object") return void 0;
+  return Object.getOwnPropertyDescriptor(value, key)?.value;
+}
+function readProjectJson(path12) {
+  const text = readProjectMetadata(path12);
+  if (text === null) return null;
+  try {
+    const value = JSON.parse(text);
+    return value;
+  } catch {
+    return null;
+  }
+}
+function readProjectManifest(dir) {
+  const parsed = readProjectJson((0, import_node_path16.join)(dir, "package.json"));
+  if (!parsed || typeof parsed !== "object") return null;
+  const record = (value) => {
+    if (!value || typeof value !== "object") return {};
+    return Object.fromEntries(
+      Object.entries(value).filter(
+        (entry) => typeof entry[1] === "string" && /^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+$/i.test(entry[0]) && entry[0] !== "." && entry[0] !== ".."
+      )
+    );
+  };
+  const name2 = metadataValue(parsed, "name");
+  return {
+    ...typeof name2 === "string" ? { name: name2 } : {},
+    dependencies: record(metadataValue(parsed, "dependencies")),
+    devDependencies: record(metadataValue(parsed, "devDependencies"))
+  };
+}
+var import_node_fs15, import_node_path16, import_json5, import_yaml, CONFIG_EXTENSIONS;
 var init_detect = __esm({
   "cli/commands/detect.ts"() {
     "use strict";
-    import_fs2 = require("fs");
-    import_path2 = require("path");
+    import_node_fs15 = require("node:fs");
+    import_node_path16 = require("node:path");
+    import_json5 = __toESM(require("json5"), 1);
+    import_yaml = require("yaml");
     CONFIG_EXTENSIONS = ["ts", "js", "cjs", "mjs", "mts", "cts"];
   }
 });
@@ -4006,21 +4059,21 @@ function resolveCloudOrigin(value) {
   return normalizeCloudOrigin(source);
 }
 function readImmutableBundleSource(bundlePath) {
-  const filepath = (0, import_node_path15.resolve)(bundlePath);
-  if ((0, import_node_path15.extname)(filepath) !== ".js") {
+  const filepath = (0, import_node_path17.resolve)(bundlePath);
+  if ((0, import_node_path17.extname)(filepath) !== ".js") {
     throw new Error(`${REMOTE_COMMAND} requires one local Metro .js bundle`);
   }
-  const descriptor = (0, import_node_fs14.openSync)(filepath, "r");
+  const descriptor = (0, import_node_fs16.openSync)(filepath, "r");
   try {
-    const before = (0, import_node_fs14.fstatSync)(descriptor, { bigint: true });
+    const before = (0, import_node_fs16.fstatSync)(descriptor, { bigint: true });
     if (!before.isFile()) {
       throw new Error(`${REMOTE_COMMAND} bundle must be a regular local file`);
     }
     if (before.size <= 0n) {
       throw new Error(`${REMOTE_COMMAND} bundle is empty`);
     }
-    const bytes = (0, import_node_fs14.readFileSync)(descriptor);
-    const after = (0, import_node_fs14.fstatSync)(descriptor, { bigint: true });
+    const bytes = (0, import_node_fs16.readFileSync)(descriptor);
+    const after = (0, import_node_fs16.fstatSync)(descriptor, { bigint: true });
     if (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeNs !== after.mtimeNs || bytes.length !== Number(before.size)) {
       throw new Error(`${REMOTE_COMMAND} bundle changed while it was being read`);
     }
@@ -4035,7 +4088,7 @@ function readImmutableBundleSource(bundlePath) {
     }
     return source;
   } finally {
-    (0, import_node_fs14.closeSync)(descriptor);
+    (0, import_node_fs16.closeSync)(descriptor);
   }
 }
 async function fetchBundleSource(bundleUrl) {
@@ -4082,15 +4135,15 @@ async function loadBundleSource(bundleInput) {
   return readImmutableBundleSource(bundleInput);
 }
 function listMetroAssetDest(assetsPath) {
-  const directory = (0, import_node_path15.resolve)(assetsPath);
-  if (!(0, import_node_fs14.existsSync)(directory)) return { directory, files: [], truncated: false };
-  const skipNested = (0, import_node_fs14.existsSync)((0, import_node_path15.join)(directory, "package.json"));
+  const directory = (0, import_node_path17.resolve)(assetsPath);
+  if (!(0, import_node_fs16.existsSync)(directory)) return { directory, files: [], truncated: false };
+  const skipNested = (0, import_node_fs16.existsSync)((0, import_node_path17.join)(directory, "package.json"));
   const files = [];
   let truncated = false;
   const walk = (dir, prefix) => {
     let entries;
     try {
-      entries = (0, import_node_fs14.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs16.readdirSync)(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -4102,7 +4155,7 @@ function listMetroAssetDest(assetsPath) {
       if (entry.isDirectory()) {
         if (entry.name === ".git") continue;
         if (skipNested && PROJECT_ONLY_DIRECTORIES.has(entry.name)) continue;
-        walk((0, import_node_path15.join)(dir, entry.name), prefix ? `${prefix}/${entry.name}` : entry.name);
+        walk((0, import_node_path17.join)(dir, entry.name), prefix ? `${prefix}/${entry.name}` : entry.name);
       } else if (entry.isFile()) {
         files.push(prefix ? `${prefix}/${entry.name}` : entry.name);
       }
@@ -4137,7 +4190,7 @@ function distinctByContent(directory, options) {
   for (const relative2 of options) {
     let bytes;
     try {
-      bytes = (0, import_node_fs14.readFileSync)((0, import_node_path15.join)(directory, relative2));
+      bytes = (0, import_node_fs16.readFileSync)((0, import_node_path17.join)(directory, relative2));
     } catch {
       continue;
     }
@@ -4169,7 +4222,7 @@ function placeMetroDescriptor(listing, descriptor) {
     let bytes;
     try {
       bytes = combination.map(
-        (relative2) => (0, import_node_fs14.readFileSync)((0, import_node_path15.join)(listing.directory, relative2))
+        (relative2) => (0, import_node_fs16.readFileSync)((0, import_node_path17.join)(listing.directory, relative2))
       );
     } catch {
       continue;
@@ -4195,26 +4248,26 @@ function placeMetroDescriptor(listing, descriptor) {
 }
 function unverifiedFileKey(dest) {
   return dest.placements.filter((placement) => !placement.verified).flatMap(
-    (placement) => [...placement.files.values()].map((relative2) => (0, import_node_path15.join)(dest.directory, relative2))
+    (placement) => [...placement.files.values()].map((relative2) => (0, import_node_path17.join)(dest.directory, relative2))
   ).sort().join("\n");
 }
 function searchMetroAssetDest(bundlePath, descriptors) {
-  const bundleDirectory = (0, import_node_path15.dirname)((0, import_node_path15.resolve)(bundlePath));
+  const bundleDirectory = (0, import_node_path17.dirname)((0, import_node_path17.resolve)(bundlePath));
   const candidates = [
-    (0, import_node_path15.join)(bundleDirectory, "assets"),
+    (0, import_node_path17.join)(bundleDirectory, "assets"),
     bundleDirectory,
-    (0, import_node_path15.resolve)(bundleDirectory, "..", "assets")
+    (0, import_node_path17.resolve)(bundleDirectory, "..", "assets")
   ];
   const cwd = process.cwd();
   let projectDirectory = null;
   for (const start of [bundleDirectory, cwd]) {
-    let directory = (0, import_node_path15.resolve)(start);
+    let directory = (0, import_node_path17.resolve)(start);
     while (true) {
       if (detectProject(directory)?.hasMetroConfig) {
         projectDirectory = directory;
         break;
       }
-      const parent = (0, import_node_path15.dirname)(directory);
+      const parent = (0, import_node_path17.dirname)(directory);
       if (parent === directory) break;
       directory = parent;
     }
@@ -4222,11 +4275,11 @@ function searchMetroAssetDest(bundlePath, descriptors) {
   }
   if (projectDirectory) {
     candidates.push(
-      (0, import_node_path15.join)(projectDirectory, "assets"),
-      (0, import_node_path15.join)(projectDirectory, "dist"),
-      (0, import_node_path15.join)(projectDirectory, "dist", "assets"),
-      (0, import_node_path15.join)(projectDirectory, "build"),
-      (0, import_node_path15.join)(projectDirectory, "build", "assets")
+      (0, import_node_path17.join)(projectDirectory, "assets"),
+      (0, import_node_path17.join)(projectDirectory, "dist"),
+      (0, import_node_path17.join)(projectDirectory, "dist", "assets"),
+      (0, import_node_path17.join)(projectDirectory, "build"),
+      (0, import_node_path17.join)(projectDirectory, "build", "assets")
     );
   }
   const searched = [];
@@ -4234,7 +4287,7 @@ function searchMetroAssetDest(bundlePath, descriptors) {
   const stale = [];
   let truncated = false;
   for (const candidate of candidates) {
-    const directory = (0, import_node_path15.resolve)(candidate);
+    const directory = (0, import_node_path17.resolve)(candidate);
     if (searched.includes(directory)) continue;
     searched.push(directory);
     const listing = listMetroAssetDest(directory);
@@ -4340,7 +4393,7 @@ async function embedBundleAssets(bundlePath, command, assetPolicy) {
       );
     }
     const relative2 = placement?.files.get(variant.scale);
-    if (relative2 && dest) return (0, import_node_fs14.readFileSync)((0, import_node_path15.join)(dest.directory, relative2));
+    if (relative2 && dest) return (0, import_node_fs16.readFileSync)((0, import_node_path17.join)(dest.directory, relative2));
     if (placement && placement.files.size > 0) return null;
     if (placement && placement.ambiguous.length > 0 && dest) {
       throw new Error(
@@ -4369,7 +4422,7 @@ async function embedBundleAssets(bundlePath, command, assetPolicy) {
     );
     const classic = metroIosAssetDestRelatives(variant.descriptor.httpServerLocation, filename)[0] ?? filename;
     throw new Error(
-      `${command} could not read ${(0, import_node_path15.join)(dest?.directory ?? ".", classic)} for ${variant.descriptor.name}.${variant.descriptor.type} at scale ${variant.scale}, and has no stand-in for a .${variant.descriptor.type} asset. Rebuild with \`react-native bundle --assets-dest\`.`
+      `${command} could not read ${(0, import_node_path17.join)(dest?.directory ?? ".", classic)} for ${variant.descriptor.name}.${variant.descriptor.type} at scale ${variant.scale}, and has no stand-in for a .${variant.descriptor.type} asset. Rebuild with \`react-native bundle --assets-dest\`.`
     );
   });
   return {
@@ -4515,13 +4568,13 @@ async function createCloudBox(options) {
     warnings: artifact.warnings
   };
 }
-var import_node_crypto6, import_node_fs14, import_node_path15, DEFAULT_RNX_CLOUD_ORIGIN, MAX_RNX_CLOUD_BUNDLE_BYTES, REMOTE_COMMAND, MAX_ASSET_DEST_FILES, ACCOUNT_CHOICE_REFUSALS, PROJECT_ONLY_DIRECTORIES, MAX_PLACEMENT_COMBINATIONS;
+var import_node_crypto6, import_node_fs16, import_node_path17, DEFAULT_RNX_CLOUD_ORIGIN, MAX_RNX_CLOUD_BUNDLE_BYTES, REMOTE_COMMAND, MAX_ASSET_DEST_FILES, ACCOUNT_CHOICE_REFUSALS, PROJECT_ONLY_DIRECTORIES, MAX_PLACEMENT_COMBINATIONS;
 var init_cloud_client = __esm({
   "cli/cloud-client.ts"() {
     "use strict";
     import_node_crypto6 = require("node:crypto");
-    import_node_fs14 = require("node:fs");
-    import_node_path15 = require("node:path");
+    import_node_fs16 = require("node:fs");
+    import_node_path17 = require("node:path");
     init_metroAssetArtifact();
     init_metroCloudArtifact();
     init_metro_fingerprint_registry_client();
@@ -4627,9 +4680,9 @@ __export(bridge_host_exports, {
 });
 module.exports = __toCommonJS(bridge_host_exports);
 var import_child_process3 = require("child_process");
-var import_fs3 = __toESM(require("fs"), 1);
+var import_fs2 = __toESM(require("fs"), 1);
 var import_http4 = require("http");
-var import_path3 = __toESM(require("path"), 1);
+var import_path2 = __toESM(require("path"), 1);
 var import_ws = require("ws");
 
 // scripts/dev-server-scanner.ts
@@ -5917,6 +5970,15 @@ async function scanDevServers(opts = {}) {
 // src/host/bridge-host.ts
 init_backend_origin();
 
+// src/automatic-update-policy.ts
+var import_node_fs4 = require("node:fs");
+var import_node_path5 = require("node:path");
+init_home_paths();
+function automaticPeachUpdatesEnabled(env = process.env) {
+  const value = env.PEACH_UPDATE_CHECK?.toLowerCase();
+  return value !== "0" && value !== "false" && value !== "off" && !(0, import_node_fs4.existsSync)((0, import_node_path5.join)(rnxHomeDir(), "runtime-update-disabled"));
+}
+
 // src/bridge-constants.ts
 var DEFAULT_SOOTSIM_BRIDGE_PORT = 7668;
 var DEFAULT_SOOTSIM_BRIDGE_URL = `http://localhost:${DEFAULT_SOOTSIM_BRIDGE_PORT}/`;
@@ -5925,7 +5987,7 @@ var SOOTSIM_BRIDGE_SIM_CLOSE_REASON = "sootsim close";
 var AUTOMATION_SIM_IDLE_REAP_TTL_MS = 5 * 6e4;
 
 // src/cli-version.ts
-var import_node_fs3 = require("node:fs");
+var import_node_fs5 = require("node:fs");
 var import_node_url2 = require("node:url");
 init_public_brand();
 var import_meta = {};
@@ -5942,7 +6004,7 @@ function getCliVersion() {
   ];
   for (const resolve5 of candidates) {
     try {
-      const version = JSON.parse((0, import_node_fs3.readFileSync)(resolve5(), "utf8")).version;
+      const version = JSON.parse((0, import_node_fs5.readFileSync)(resolve5(), "utf8")).version;
       if (typeof version === "string" && version) {
         cached2 = version;
         return cached2;
@@ -5966,27 +6028,27 @@ var import_url = require("url");
 // ../contrast-runtime-delivery/src/index.ts
 var import_node_child_process2 = require("node:child_process");
 var import_node_crypto2 = __toESM(require("node:crypto"), 1);
-var import_node_fs6 = __toESM(require("node:fs"), 1);
+var import_node_fs7 = __toESM(require("node:fs"), 1);
 var import_node_os2 = __toESM(require("node:os"), 1);
-var import_node_path6 = __toESM(require("node:path"), 1);
+var import_node_path7 = __toESM(require("node:path"), 1);
 var import_node_stream = require("node:stream");
 var import_promises3 = require("node:stream/promises");
 
 // ../contrast-runtime-delivery/src/product.ts
-var import_node_fs5 = __toESM(require("node:fs"), 1);
-var import_node_path5 = __toESM(require("node:path"), 1);
+var import_node_fs6 = __toESM(require("node:fs"), 1);
+var import_node_path6 = __toESM(require("node:path"), 1);
 function isValidRuntimeVersion(value) {
   return value.length <= 100 && /^[0-9A-Za-z][0-9A-Za-z._+-]*$/.test(value);
 }
 function listInstalledRuntimes(product) {
   try {
-    return import_node_fs5.default.readdirSync(product.runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
+    return import_node_fs6.default.readdirSync(product.runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
   } catch {
     return [];
   }
 }
 function runtimeTarballCacheName(product, version) {
-  return import_node_path5.default.posix.basename(product.tarballPath(version));
+  return import_node_path6.default.posix.basename(product.tarballPath(version));
 }
 function compareSemver(a, b) {
   const parse2 = (v) => {
@@ -6016,7 +6078,7 @@ function createRuntimeDelivery(product) {
   function readConfig() {
     try {
       const parsed = JSON.parse(
-        import_node_fs6.default.readFileSync(product.configFile(), "utf8")
+        import_node_fs7.default.readFileSync(product.configFile(), "utf8")
       );
       return parsed && typeof parsed === "object" ? parsed : {};
     } catch {
@@ -6089,7 +6151,7 @@ function createRuntimeDelivery(product) {
     const setActive = opts.setActive !== false;
     const protectVersions = [version, ...opts.protectVersions ?? []];
     pruneLocalRetention({ protectVersions });
-    if (!opts.force && import_node_fs6.default.existsSync(import_node_path6.default.join(destDir, product.installedMarker))) {
+    if (!opts.force && import_node_fs7.default.existsSync(import_node_path7.default.join(destDir, product.installedMarker))) {
       if (setActive) product.writeActiveRuntime(version);
       pruneLocalRetention({ protectVersions });
       return {
@@ -6103,18 +6165,18 @@ function createRuntimeDelivery(product) {
       };
     }
     const tarUrl = entry.tarball || tarballUrl(version, cdnOrigin);
-    const downloadDir = import_node_fs6.default.mkdtempSync(
-      import_node_path6.default.join(import_node_os2.default.tmpdir(), `${product.id}-runtime-download-`)
+    const downloadDir = import_node_fs7.default.mkdtempSync(
+      import_node_path7.default.join(import_node_os2.default.tmpdir(), `${product.id}-runtime-download-`)
     );
-    const runtimeArchivePath = import_node_path6.default.join(
+    const runtimeArchivePath = import_node_path7.default.join(
       downloadDir,
       runtimeTarballCacheName(product, version)
     );
-    const tmpDir = import_node_path6.default.join(
-      import_node_path6.default.dirname(destDir),
+    const tmpDir = import_node_path7.default.join(
+      import_node_path7.default.dirname(destDir),
       `.installing-${version}-${process.pid}`
     );
-    import_node_fs6.default.rmSync(tmpDir, { recursive: true, force: true });
+    import_node_fs7.default.rmSync(tmpDir, { recursive: true, force: true });
     try {
       if (!opts.quiet)
         process.stderr.write(`${product.id}: downloading runtime ${version}\u2026
@@ -6129,20 +6191,20 @@ function createRuntimeDelivery(product) {
           `sha256 mismatch for runtime ${version}: expected ${entry.sha256}, actual ${actualSha}`
         );
       }
-      import_node_fs6.default.mkdirSync(tmpDir, { recursive: true });
+      import_node_fs7.default.mkdirSync(tmpDir, { recursive: true });
       await extractTarball(runtimeArchivePath, tmpDir);
-      if (!import_node_fs6.default.existsSync(import_node_path6.default.join(tmpDir, product.installedMarker))) {
+      if (!import_node_fs7.default.existsSync(import_node_path7.default.join(tmpDir, product.installedMarker))) {
         throw new Error(
           `extracted tarball for runtime ${version} is missing ${product.installedMarker}`
         );
       }
-      import_node_fs6.default.rmSync(destDir, { recursive: true, force: true });
-      import_node_fs6.default.renameSync(tmpDir, destDir);
+      import_node_fs7.default.rmSync(destDir, { recursive: true, force: true });
+      import_node_fs7.default.renameSync(tmpDir, destDir);
     } catch (err) {
-      import_node_fs6.default.rmSync(tmpDir, { recursive: true, force: true });
+      import_node_fs7.default.rmSync(tmpDir, { recursive: true, force: true });
       throw err;
     } finally {
-      import_node_fs6.default.rmSync(downloadDir, { recursive: true, force: true });
+      import_node_fs7.default.rmSync(downloadDir, { recursive: true, force: true });
     }
     if (setActive) product.writeActiveRuntime(version);
     pruneLocalRetention({ protectVersions });
@@ -6164,8 +6226,8 @@ function createRuntimeDelivery(product) {
     const pin = resolvePin();
     if (pin) {
       const activeVersion2 = product.readActiveRuntime();
-      const pinInstalled = import_node_fs6.default.existsSync(
-        import_node_path6.default.join(product.runtimeDir(pin), product.installedMarker)
+      const pinInstalled = import_node_fs7.default.existsSync(
+        import_node_path7.default.join(product.runtimeDir(pin), product.installedMarker)
       );
       if (activeVersion2 === pin && pinInstalled) {
         return {
@@ -6214,7 +6276,7 @@ function createRuntimeDelivery(product) {
     }
     const activeVersion = product.readActiveRuntime();
     const activeDir = activeVersion ? product.runtimeDir(activeVersion) : null;
-    const activeInstalled = activeDir ? import_node_fs6.default.existsSync(import_node_path6.default.join(activeDir, product.installedMarker)) : false;
+    const activeInstalled = activeDir ? import_node_fs7.default.existsSync(import_node_path7.default.join(activeDir, product.installedMarker)) : false;
     const shouldInstall = !activeVersion || !activeInstalled || compareSemver(latestVersion, activeVersion) > 0;
     if (!shouldInstall) {
       return {
@@ -6289,12 +6351,12 @@ function createRuntimeDelivery(product) {
     let removeCacheFiles = [];
     if (markerOffset >= 0) {
       try {
-        removeCacheFiles = import_node_fs6.default.readdirSync(product.cacheDir(), { withFileTypes: true }).filter((entry) => {
+        removeCacheFiles = import_node_fs7.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`);
           return complete || partial;
-        }).map((entry) => import_node_path6.default.join(product.cacheDir(), entry.name)).sort();
+        }).map((entry) => import_node_path7.default.join(product.cacheDir(), entry.name)).sort();
       } catch {
       }
     }
@@ -6309,10 +6371,10 @@ function createRuntimeDelivery(product) {
   function pruneLocalRetention(opts = {}) {
     const plan = planLocalRetention(opts);
     for (const version of plan.removeVersions) {
-      import_node_fs6.default.rmSync(product.runtimeDir(version), { recursive: true, force: true });
+      import_node_fs7.default.rmSync(product.runtimeDir(version), { recursive: true, force: true });
     }
     for (const cacheFile of plan.removeCacheFiles) {
-      import_node_fs6.default.rmSync(cacheFile, { force: true });
+      import_node_fs7.default.rmSync(cacheFile, { force: true });
     }
     return plan;
   }
@@ -6338,17 +6400,17 @@ async function downloadToFile(url, destPath) {
   if (!res.ok || !res.body) {
     throw new Error(`download failed: ${res.status} ${res.statusText} (${url})`);
   }
-  import_node_fs6.default.mkdirSync(import_node_path6.default.dirname(destPath), { recursive: true });
+  import_node_fs7.default.mkdirSync(import_node_path7.default.dirname(destPath), { recursive: true });
   const tmp = `${destPath}.partial`;
   try {
     await (0, import_promises3.pipeline)(
       import_node_stream.Readable.fromWeb(res.body),
-      import_node_fs6.default.createWriteStream(tmp)
+      import_node_fs7.default.createWriteStream(tmp)
     );
-    import_node_fs6.default.renameSync(tmp, destPath);
+    import_node_fs7.default.renameSync(tmp, destPath);
   } catch (err) {
     try {
-      import_node_fs6.default.unlinkSync(tmp);
+      import_node_fs7.default.unlinkSync(tmp);
     } catch {
     }
     throw err;
@@ -6357,7 +6419,7 @@ async function downloadToFile(url, destPath) {
 function sha256File(filePath) {
   return new Promise((resolve5, reject) => {
     const hash = import_node_crypto2.default.createHash("sha256");
-    const stream = import_node_fs6.default.createReadStream(filePath);
+    const stream = import_node_fs7.default.createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
     stream.on("end", () => resolve5(hash.digest("hex")));
@@ -6506,19 +6568,19 @@ var rnxRuntime = createRuntimeDelivery(RNX_RUNTIME_PRODUCT);
 
 // src/host/agent-host.ts
 var import_node_crypto5 = require("node:crypto");
-var import_node_fs10 = __toESM(require("node:fs"), 1);
-var import_node_path10 = __toESM(require("node:path"), 1);
+var import_node_fs11 = __toESM(require("node:fs"), 1);
+var import_node_path11 = __toESM(require("node:path"), 1);
 
 // src/agent-sessions.ts
 var import_node_child_process3 = require("node:child_process");
 var import_node_crypto4 = require("node:crypto");
-var import_node_fs9 = __toESM(require("node:fs"), 1);
-var import_node_path9 = __toESM(require("node:path"), 1);
+var import_node_fs10 = __toESM(require("node:fs"), 1);
+var import_node_path10 = __toESM(require("node:path"), 1);
 var import_node_readline = __toESM(require("node:readline"), 1);
 
 // cli/self-invocation.ts
-var import_node_fs7 = require("node:fs");
-var import_node_path7 = require("node:path");
+var import_node_fs8 = require("node:fs");
+var import_node_path8 = require("node:path");
 var import_node_url3 = require("node:url");
 init_public_brand();
 
@@ -6528,14 +6590,14 @@ var IS_STANDALONE = typeof __SOOTSIM_STANDALONE__ !== "undefined" && __SOOTSIM_S
 // cli/self-invocation.ts
 function sourceEntryPath() {
   try {
-    const candidate = (0, import_node_path7.join)((0, import_node_path7.dirname)((0, import_node_url3.fileURLToPath)(__sootsim_import_meta_url)), "bin.ts");
-    return (0, import_node_fs7.existsSync)(candidate) ? candidate : null;
+    const candidate = (0, import_node_path8.join)((0, import_node_path8.dirname)((0, import_node_url3.fileURLToPath)(__sootsim_import_meta_url)), "bin.ts");
+    return (0, import_node_fs8.existsSync)(candidate) ? candidate : null;
   } catch {
     return null;
   }
 }
 function isCliEntry(path12) {
-  const name2 = (0, import_node_path7.basename)(path12);
+  const name2 = (0, import_node_path8.basename)(path12);
   return name2 === "bin.ts" || name2 === "bin.js";
 }
 function rnxSelfInvocation() {
@@ -6595,8 +6657,8 @@ function encodeAgentPromptEnvelope(input) {
 
 // src/attached-projects.ts
 var import_node_crypto3 = require("node:crypto");
-var import_node_fs8 = __toESM(require("node:fs"), 1);
-var import_node_path8 = __toESM(require("node:path"), 1);
+var import_node_fs9 = __toESM(require("node:fs"), 1);
+var import_node_path9 = __toESM(require("node:path"), 1);
 init_home_paths();
 var overrideDir = null;
 function userDataDir() {
@@ -6609,7 +6671,7 @@ function getUserDataDir() {
   return userDataDir();
 }
 function storeFile() {
-  return import_node_path8.default.join(userDataDir(), "attached-projects.json");
+  return import_node_path9.default.join(userDataDir(), "attached-projects.json");
 }
 function cloneEmpty() {
   return {
@@ -6623,7 +6685,7 @@ function loadStore() {
   const file = storeFile();
   let raw;
   try {
-    raw = import_node_fs8.default.readFileSync(file, "utf8");
+    raw = import_node_fs9.default.readFileSync(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return cloneEmpty();
     throw err;
@@ -6640,7 +6702,7 @@ function loadStore() {
   } catch (err) {
     const quarantine = `${file}.corrupt-${Date.now()}`;
     try {
-      import_node_fs8.default.renameSync(file, quarantine);
+      import_node_fs9.default.renameSync(file, quarantine);
       console.warn(
         `[sootsim] attached-projects.json was unparseable; quarantined to ${quarantine}. original error: ${err.message}`
       );
@@ -6651,16 +6713,16 @@ function loadStore() {
 }
 function writeStore(store) {
   const file = storeFile();
-  import_node_fs8.default.mkdirSync(import_node_path8.default.dirname(file), { recursive: true });
+  import_node_fs9.default.mkdirSync(import_node_path9.default.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-  const fd = import_node_fs8.default.openSync(tmp, "w", 384);
+  const fd = import_node_fs9.default.openSync(tmp, "w", 384);
   try {
-    import_node_fs8.default.writeFileSync(fd, JSON.stringify(store, null, 2));
-    import_node_fs8.default.fsyncSync(fd);
+    import_node_fs9.default.writeFileSync(fd, JSON.stringify(store, null, 2));
+    import_node_fs9.default.fsyncSync(fd);
   } finally {
-    import_node_fs8.default.closeSync(fd);
+    import_node_fs9.default.closeSync(fd);
   }
-  import_node_fs8.default.renameSync(tmp, file);
+  import_node_fs9.default.renameSync(tmp, file);
 }
 function mutateStore(fn) {
   const store = loadStore();
@@ -6669,13 +6731,13 @@ function mutateStore(fn) {
   return store;
 }
 function projectIdForCwd(cwd) {
-  return (0, import_node_crypto3.createHash)("sha256").update(import_node_path8.default.resolve(cwd)).digest("hex").slice(0, 16);
+  return (0, import_node_crypto3.createHash)("sha256").update(import_node_path9.default.resolve(cwd)).digest("hex").slice(0, 16);
 }
 function newSessionId() {
   return `s_${(0, import_node_crypto3.randomBytes)(10).toString("hex")}`;
 }
 function upsertProject(input) {
-  const cwd = import_node_path8.default.resolve(input.cwd);
+  const cwd = import_node_path9.default.resolve(input.cwd);
   const id = projectIdForCwd(cwd);
   let result;
   mutateStore((store) => {
@@ -6701,7 +6763,7 @@ function upsertProject(input) {
     const now = Date.now();
     const created = {
       id,
-      name: input.name ?? import_node_path8.default.basename(cwd),
+      name: input.name ?? import_node_path9.default.basename(cwd),
       cwd,
       repoRoot: input.repoRoot,
       sourceRoots: input.sourceRoots ?? [cwd],
@@ -6847,8 +6909,8 @@ async function seedFromDemoAppRegistry() {
   if (apps.length === 0) return;
   mutateStore((store) => {
     for (const app of apps) {
-      if (!import_node_fs8.default.existsSync(app.dir)) continue;
-      const cwd = import_node_path8.default.resolve(app.dir);
+      if (!import_node_fs9.default.existsSync(app.dir)) continue;
+      const cwd = import_node_path9.default.resolve(app.dir);
       const id = projectIdForCwd(cwd);
       if (store.attachedProjects.some((p) => p.id === id)) continue;
       const now = Date.now();
@@ -6873,16 +6935,16 @@ async function seedFromDemoAppRegistry() {
 // src/agent-sessions.ts
 init_public_brand();
 function sessionDir(sessionId) {
-  return import_node_path9.default.join(getUserDataDir(), "sessions", sessionId);
+  return import_node_path10.default.join(getUserDataDir(), "sessions", sessionId);
 }
 function promptFifoPath(sessionId) {
-  return import_node_path9.default.join(sessionDir(sessionId), "prompt.in");
+  return import_node_path10.default.join(sessionDir(sessionId), "prompt.in");
 }
 function eventsFifoPath(sessionId) {
-  return import_node_path9.default.join(sessionDir(sessionId), "events.out");
+  return import_node_path10.default.join(sessionDir(sessionId), "events.out");
 }
 function transcriptPath(sessionId) {
-  return import_node_path9.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
+  return import_node_path10.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
 }
 function pidIsAlive(pid, sessionId) {
   if (!pid) return false;
@@ -6892,7 +6954,7 @@ function pidIsAlive(pid, sessionId) {
     return false;
   }
   if (sessionId) {
-    if (!import_node_fs9.default.existsSync(sessionDir(sessionId))) return false;
+    if (!import_node_fs10.default.existsSync(sessionDir(sessionId))) return false;
   }
   return true;
 }
@@ -6905,11 +6967,11 @@ function resolveSootsimInvocation() {
     const resourcesPath = process.resourcesPath;
     if (resourcesPath) {
       const candidates = [
-        import_node_path9.default.join(resourcesPath, "bin", "sootsim"),
-        import_node_path9.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
+        import_node_path10.default.join(resourcesPath, "bin", "sootsim"),
+        import_node_path10.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
       ];
       for (const c of candidates) {
-        if (import_node_fs9.default.existsSync(c)) return { executable: c, prefixArgs: [] };
+        if (import_node_fs10.default.existsSync(c)) return { executable: c, prefixArgs: [] };
       }
     }
   }
@@ -6928,15 +6990,15 @@ function tryWorkspaceSootsim() {
     const sootsimDir = resolveSootsimPackageDir();
     if (!sootsimDir) return null;
     const binaryName = `peach-${process.platform === "win32" ? "windows" : process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`;
-    const distBinary = import_node_path9.default.join(sootsimDir, "dist-bin", binaryName);
-    if (import_node_fs9.default.existsSync(distBinary)) return { executable: distBinary, prefixArgs: [] };
-    const distBin = import_node_path9.default.join(sootsimDir, "dist-cli", "bin.js");
-    if (import_node_fs9.default.existsSync(distBin)) {
+    const distBinary = import_node_path10.default.join(sootsimDir, "dist-bin", binaryName);
+    if (import_node_fs10.default.existsSync(distBinary)) return { executable: distBinary, prefixArgs: [] };
+    const distBin = import_node_path10.default.join(sootsimDir, "dist-cli", "bin.js");
+    if (import_node_fs10.default.existsSync(distBin)) {
       try {
-        const src = import_node_path9.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
-        if (import_node_fs9.default.existsSync(src)) {
-          const srcMtime = import_node_fs9.default.statSync(src).mtimeMs;
-          const buildMtime = import_node_fs9.default.statSync(distBin).mtimeMs;
+        const src = import_node_path10.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
+        if (import_node_fs10.default.existsSync(src)) {
+          const srcMtime = import_node_fs10.default.statSync(src).mtimeMs;
+          const buildMtime = import_node_fs10.default.statSync(distBin).mtimeMs;
           if (buildMtime < srcMtime) {
             console.warn(
               `[peach] dist-cli/bin.js is older than agent-wrapper.ts \u2014 rebuild with \`bun run --cwd packages/peachsim build:cli\`.`
@@ -6955,22 +7017,22 @@ function tryWorkspaceSootsim() {
 function resolveSootsimPackageDir() {
   try {
     const resolved = require.resolve(`${rnxPublicBrand.packageName}/package.json`);
-    return import_node_path9.default.dirname(resolved);
+    return import_node_path10.default.dirname(resolved);
   } catch {
   }
   const here = fileFromImportMeta();
   if (!here) return null;
-  let cur = import_node_path9.default.dirname(here);
+  let cur = import_node_path10.default.dirname(here);
   for (let i = 0; i < 8; i++) {
-    const pkg = import_node_path9.default.join(cur, "package.json");
+    const pkg = import_node_path10.default.join(cur, "package.json");
     try {
-      if (import_node_fs9.default.existsSync(pkg)) {
-        const parsed = JSON.parse(import_node_fs9.default.readFileSync(pkg, "utf8"));
+      if (import_node_fs10.default.existsSync(pkg)) {
+        const parsed = JSON.parse(import_node_fs10.default.readFileSync(pkg, "utf8"));
         if (parsed.name === rnxPublicBrand.packageName) return cur;
       }
     } catch {
     }
-    const parent = import_node_path9.default.dirname(cur);
+    const parent = import_node_path10.default.dirname(cur);
     if (parent === cur) break;
     cur = parent;
   }
@@ -6986,28 +7048,28 @@ function fileFromImportMeta() {
   }
 }
 async function withStartLock(projectId, provider, fn) {
-  const lockDir = import_node_path9.default.join(getUserDataDir(), "locks");
-  import_node_fs9.default.mkdirSync(lockDir, { recursive: true });
+  const lockDir = import_node_path10.default.join(getUserDataDir(), "locks");
+  import_node_fs10.default.mkdirSync(lockDir, { recursive: true });
   try {
-    import_node_fs9.default.chmodSync(lockDir, 448);
+    import_node_fs10.default.chmodSync(lockDir, 448);
   } catch {
   }
-  const lockPath = import_node_path9.default.join(lockDir, `start-${projectId}-${provider}.lock`);
+  const lockPath = import_node_path10.default.join(lockDir, `start-${projectId}-${provider}.lock`);
   const deadline = Date.now() + 4e3;
   let fd = null;
   while (fd === null) {
     try {
-      fd = import_node_fs9.default.openSync(
+      fd = import_node_fs10.default.openSync(
         lockPath,
-        import_node_fs9.constants.O_WRONLY | import_node_fs9.constants.O_CREAT | import_node_fs9.constants.O_EXCL,
+        import_node_fs10.constants.O_WRONLY | import_node_fs10.constants.O_CREAT | import_node_fs10.constants.O_EXCL,
         384
       );
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       try {
-        const stale = Number(import_node_fs9.default.readFileSync(lockPath, "utf8").trim());
+        const stale = Number(import_node_fs10.default.readFileSync(lockPath, "utf8").trim());
         if (stale && !isProcessAlive(stale)) {
-          import_node_fs9.default.unlinkSync(lockPath);
+          import_node_fs10.default.unlinkSync(lockPath);
           continue;
         }
       } catch {
@@ -7021,15 +7083,15 @@ async function withStartLock(projectId, provider, fn) {
     }
   }
   try {
-    import_node_fs9.default.writeFileSync(fd, String(process.pid));
+    import_node_fs10.default.writeFileSync(fd, String(process.pid));
     return await fn();
   } finally {
     try {
-      import_node_fs9.default.closeSync(fd);
+      import_node_fs10.default.closeSync(fd);
     } catch {
     }
     try {
-      import_node_fs9.default.unlinkSync(lockPath);
+      import_node_fs10.default.unlinkSync(lockPath);
     } catch {
     }
   }
@@ -7043,25 +7105,25 @@ function isProcessAlive(pid) {
   }
 }
 function mkfifoSync(p) {
-  const parent = import_node_path9.default.dirname(p);
-  import_node_fs9.default.mkdirSync(parent, { recursive: true });
+  const parent = import_node_path10.default.dirname(p);
+  import_node_fs10.default.mkdirSync(parent, { recursive: true });
   try {
-    import_node_fs9.default.chmodSync(parent, 448);
+    import_node_fs10.default.chmodSync(parent, 448);
   } catch {
   }
-  if (import_node_fs9.default.existsSync(p)) {
+  if (import_node_fs10.default.existsSync(p)) {
     try {
-      const stat2 = import_node_fs9.default.statSync(p);
+      const stat2 = import_node_fs10.default.statSync(p);
       if (stat2.isFIFO()) {
         try {
-          import_node_fs9.default.chmodSync(p, 384);
+          import_node_fs10.default.chmodSync(p, 384);
         } catch {
         }
         return;
       }
-      import_node_fs9.default.unlinkSync(p);
+      import_node_fs10.default.unlinkSync(p);
     } catch {
-      import_node_fs9.default.unlinkSync(p);
+      import_node_fs10.default.unlinkSync(p);
     }
   }
   const result = (0, import_node_child_process3.spawnSync)("mkfifo", ["-m", "600", p]);
@@ -7108,10 +7170,10 @@ async function startSession(opts) {
     const transcript = transcriptPath(session.id);
     mkfifoSync(promptIn);
     mkfifoSync(eventsOut);
-    const transcriptDir = import_node_path9.default.dirname(transcript);
-    import_node_fs9.default.mkdirSync(transcriptDir, { recursive: true });
+    const transcriptDir = import_node_path10.default.dirname(transcript);
+    import_node_fs10.default.mkdirSync(transcriptDir, { recursive: true });
     try {
-      import_node_fs9.default.chmodSync(transcriptDir, 448);
+      import_node_fs10.default.chmodSync(transcriptDir, 448);
     } catch {
     }
     const { executable, prefixArgs } = resolveSootsimInvocation();
@@ -7162,7 +7224,7 @@ async function startSession(opts) {
         }
       }
       try {
-        import_node_fs9.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
+        import_node_fs10.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
       } catch {
       }
       updateSessionStatus(session.id, { status: "ended" });
@@ -7190,18 +7252,18 @@ async function sendPrompt(sessionId, prompt) {
     );
   }
   const fifo = promptFifoPath(sessionId);
-  if (!import_node_fs9.default.existsSync(fifo)) {
+  if (!import_node_fs10.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `prompt FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs9.default.openSync(fifo, import_node_fs9.constants.O_WRONLY);
+  const fd = import_node_fs10.default.openSync(fifo, import_node_fs10.constants.O_WRONLY);
   try {
     const wireText = encodeAgentPromptEnvelope(prompt);
     if (!wireText) {
       throw new AgentSessionError("EMPTY_PROMPT", "prompt text is empty");
     }
-    import_node_fs9.default.writeSync(fd, wireText + "\n");
+    import_node_fs10.default.writeSync(fd, wireText + "\n");
   } finally {
-    import_node_fs9.default.closeSync(fd);
+    import_node_fs10.default.closeSync(fd);
   }
   updateSessionStatus(sessionId, {
     lastPrompt: prompt.displayText ?? prompt.text,
@@ -7223,7 +7285,7 @@ async function endSession(sessionId) {
   const base = getUserDataDir();
   if (dir.startsWith(base)) {
     try {
-      import_node_fs9.default.rmSync(dir, { recursive: true, force: true });
+      import_node_fs10.default.rmSync(dir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -7231,11 +7293,11 @@ async function endSession(sessionId) {
 }
 function subscribeEvents(sessionId, onEvent) {
   const fifo = eventsFifoPath(sessionId);
-  if (!import_node_fs9.default.existsSync(fifo)) {
+  if (!import_node_fs10.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `events FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs9.default.openSync(fifo, import_node_fs9.constants.O_RDWR);
-  const stream = import_node_fs9.default.createReadStream("", { fd, autoClose: true });
+  const fd = import_node_fs10.default.openSync(fifo, import_node_fs10.constants.O_RDWR);
+  const stream = import_node_fs10.default.createReadStream("", { fd, autoClose: true });
   const rl = import_node_readline.default.createInterface({ input: stream, crlfDelay: Infinity });
   rl.on("line", (line) => {
     const event = parseAgentEventLine(line);
@@ -7246,7 +7308,7 @@ function subscribeEvents(sessionId, onEvent) {
     if (closed) return;
     closed = true;
     try {
-      import_node_fs9.default.writeSync(fd, "\n");
+      import_node_fs10.default.writeSync(fd, "\n");
     } catch {
     }
     try {
@@ -7260,7 +7322,7 @@ function subscribeEvents(sessionId, onEvent) {
   };
 }
 async function waitForFirstEvent(fifo, predicate, timeoutMs) {
-  const fd = import_node_fs9.default.openSync(fifo, import_node_fs9.constants.O_RDWR | import_node_fs9.constants.O_NONBLOCK);
+  const fd = import_node_fs10.default.openSync(fifo, import_node_fs10.constants.O_RDWR | import_node_fs10.constants.O_NONBLOCK);
   const buf = Buffer.alloc(8192);
   let leftover = "";
   const deadline = Date.now() + timeoutMs;
@@ -7268,7 +7330,7 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     while (Date.now() < deadline) {
       let n = 0;
       try {
-        n = import_node_fs9.default.readSync(fd, buf, 0, buf.length, null);
+        n = import_node_fs10.default.readSync(fd, buf, 0, buf.length, null);
       } catch (err) {
         if (err.code !== "EAGAIN") throw err;
         n = 0;
@@ -7288,7 +7350,7 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     }
     return null;
   } finally {
-    import_node_fs9.default.closeSync(fd);
+    import_node_fs10.default.closeSync(fd);
   }
 }
 
@@ -7542,7 +7604,7 @@ var AgentHost = class {
     );
     const project = upsertProject({
       cwd: match.cwd,
-      name: match.projectName ?? import_node_path10.default.basename(match.cwd),
+      name: match.projectName ?? import_node_path11.default.basename(match.cwd),
       preferredProvider: input.provider ?? existing?.preferredProvider,
       sourceRoots: existing?.sourceRoots ?? [match.cwd],
       knownBundleUrls,
@@ -7553,18 +7615,18 @@ var AgentHost = class {
   }
   getTranscript(sessionId) {
     const p = transcriptPath(sessionId);
-    if (!import_node_fs10.default.existsSync(p)) {
+    if (!import_node_fs11.default.existsSync(p)) {
       return { error: "transcript not found", code: "NO_TRANSCRIPT" };
     }
-    return import_node_fs10.default.readFileSync(p, "utf8");
+    return import_node_fs11.default.readFileSync(p, "utf8");
   }
   getPaths() {
     const dir = getUserDataDir();
     return {
       userDataDir: dir,
-      storeFile: import_node_path10.default.join(dir, "attached-projects.json"),
-      sessionsDir: import_node_path10.default.join(dir, "sessions"),
-      transcriptsDir: import_node_path10.default.join(dir, "transcripts")
+      storeFile: import_node_path11.default.join(dir, "attached-projects.json"),
+      sessionsDir: import_node_path11.default.join(dir, "sessions"),
+      transcriptsDir: import_node_path11.default.join(dir, "transcripts")
     };
   }
   // --- subscription management ---
@@ -8271,8 +8333,8 @@ async function openUrl(url, options = {}) {
 }
 
 // src/host/plane-host.ts
-var import_node_fs12 = __toESM(require("node:fs"), 1);
-var import_node_path12 = __toESM(require("node:path"), 1);
+var import_node_fs13 = __toESM(require("node:fs"), 1);
+var import_node_path13 = __toESM(require("node:path"), 1);
 
 // ../peach-box/src/planeProtocol.ts
 var PLANE_FLAG_READ_ONLY = 1;
@@ -8352,8 +8414,8 @@ async function dispatchPlaneCommand(plane, type, msg, mutationOptions) {
 
 // cli/commands/box/checkout-plane.ts
 var import_node_child_process4 = require("node:child_process");
-var import_node_fs11 = __toESM(require("node:fs"), 1);
-var import_node_path11 = __toESM(require("node:path"), 1);
+var import_node_fs12 = __toESM(require("node:fs"), 1);
+var import_node_path12 = __toESM(require("node:path"), 1);
 var CheckoutRequiresGitError = class extends Error {
 };
 var BINARY_SNIFF_BYTES = 8192;
@@ -8364,14 +8426,14 @@ function looksBinary(filePath, size) {
   if (size === 0) return false;
   let fd;
   try {
-    fd = import_node_fs11.default.openSync(filePath, "r");
+    fd = import_node_fs12.default.openSync(filePath, "r");
     const buffer = Buffer.alloc(Math.min(BINARY_SNIFF_BYTES, size));
-    const read = import_node_fs11.default.readSync(fd, buffer, 0, buffer.length, 0);
+    const read = import_node_fs12.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_fs11.default.closeSync(fd);
+    if (fd !== void 0) import_node_fs12.default.closeSync(fd);
   }
 }
 var CheckoutFilePlane = class {
@@ -8384,7 +8446,7 @@ var CheckoutFilePlane = class {
   listTimeoutMs;
   trackedOnly;
   constructor(root, options = {}) {
-    this.root = import_node_path11.default.resolve(root);
+    this.root = import_node_path12.default.resolve(root);
     this.listTimeoutMs = options.listTimeoutMs ?? LIST_FILES_TIMEOUT_MS;
     this.trackedOnly = options.trackedOnly ?? false;
   }
@@ -8446,13 +8508,13 @@ var CheckoutFilePlane = class {
       if (!relative2) continue;
       let stat2;
       try {
-        stat2 = import_node_fs11.default.statSync(import_node_path11.default.join(this.root, relative2));
+        stat2 = import_node_fs12.default.statSync(import_node_path12.default.join(this.root, relative2));
       } catch {
         continue;
       }
       if (!stat2.isFile()) continue;
       const seen = this.sniffed.get(relative2);
-      const binary = seen && seen.size === stat2.size && seen.mtimeMs === stat2.mtimeMs ? seen.binary : looksBinary(import_node_path11.default.join(this.root, relative2), stat2.size);
+      const binary = seen && seen.size === stat2.size && seen.mtimeMs === stat2.mtimeMs ? seen.binary : looksBinary(import_node_path12.default.join(this.root, relative2), stat2.size);
       nextSniffed.set(relative2, { size: stat2.size, mtimeMs: stat2.mtimeMs, binary });
       next.set(relative2, {
         size: stat2.size,
@@ -8466,22 +8528,22 @@ var CheckoutFilePlane = class {
     this.sniffed = nextSniffed;
   }
   absolute(planePath) {
-    const resolved = import_node_path11.default.resolve(this.root, planePath);
-    if (resolved !== this.root && !resolved.startsWith(`${this.root}${import_node_path11.default.sep}`)) {
+    const resolved = import_node_path12.default.resolve(this.root, planePath);
+    if (resolved !== this.root && !resolved.startsWith(`${this.root}${import_node_path12.default.sep}`)) {
       throw new Error(`path escapes the project: ${planePath}`);
     }
     return resolved;
   }
   async read(planePath) {
-    return import_node_fs11.default.promises.readFile(this.absolute(planePath), "utf8");
+    return import_node_fs12.default.promises.readFile(this.absolute(planePath), "utf8");
   }
   async readBytes(planePath) {
-    return import_node_fs11.default.promises.readFile(this.absolute(planePath));
+    return import_node_fs12.default.promises.readFile(this.absolute(planePath));
   }
   async write(planePath, content) {
     const absolute = this.absolute(planePath);
-    await import_node_fs11.default.promises.mkdir(import_node_path11.default.dirname(absolute), { recursive: true });
-    await import_node_fs11.default.promises.writeFile(absolute, content);
+    await import_node_fs12.default.promises.mkdir(import_node_path12.default.dirname(absolute), { recursive: true });
+    await import_node_fs12.default.promises.writeFile(absolute, content);
     this.entries.set(planePath, {
       size: content.byteLength,
       readOnly: false,
@@ -8490,7 +8552,7 @@ var CheckoutFilePlane = class {
     });
   }
   async delete(planePath) {
-    await import_node_fs11.default.promises.rm(this.absolute(planePath), { force: true });
+    await import_node_fs12.default.promises.rm(this.absolute(planePath), { force: true });
     this.entries.delete(planePath);
   }
 };
@@ -8616,14 +8678,14 @@ var PlaneHost = class {
   // root and an opened one cannot disagree about the same directory.
   realRoot(root) {
     if (!root) throw new Error("root is required");
-    const resolved = import_node_path12.default.resolve(root);
+    const resolved = import_node_path13.default.resolve(root);
     let real;
     try {
-      real = import_node_fs12.default.realpathSync(resolved);
+      real = import_node_fs13.default.realpathSync(resolved);
     } catch {
       throw new Error(`no such directory: ${resolved}`);
     }
-    if (!import_node_fs12.default.statSync(real).isDirectory()) throw new Error(`not a directory: ${real}`);
+    if (!import_node_fs13.default.statSync(real).isDirectory()) throw new Error(`not a directory: ${real}`);
     return real;
   }
   respond(ws, id, result) {
@@ -8644,7 +8706,7 @@ var PlaneHost = class {
 
 // src/host/replacement-module-handler.ts
 var import_promises5 = __toESM(require("node:fs/promises"), 1);
-var import_node_path13 = __toESM(require("node:path"), 1);
+var import_node_path14 = __toESM(require("node:path"), 1);
 
 // ../contrast-bundler/src/replacementModule.ts
 var import_dist = require("sucrase/dist/index.js");
@@ -8683,7 +8745,7 @@ function normalize(p) {
   if (trailingSlash) joined += "/";
   return absolute ? "/" + joined : joined;
 }
-function join4(...parts) {
+function join5(...parts) {
   const present = parts.filter((part) => part.length > 0);
   if (present.length === 0) return ".";
   return normalize(present.join("/"));
@@ -8740,7 +8802,7 @@ var posix = {
   delimiter,
   isAbsolute,
   normalize,
-  join: join4,
+  join: join5,
   resolve: resolve2,
   dirname: dirname3,
   basename: basename3,
@@ -8998,13 +9060,13 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
     res.end("missing path param");
     return true;
   }
-  const extension = import_node_path13.default.extname(targetPath).toLowerCase();
+  const extension = import_node_path14.default.extname(targetPath).toLowerCase();
   if (!REPLACEMENT_MODULE_EXTENSIONS.some((allowed) => allowed === extension)) {
     res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
     res.end(`replacement files must be ${REPLACEMENT_MODULE_EXTENSIONS.join(", ")}`);
     return true;
   }
-  if (!import_node_path13.default.isAbsolute(targetPath)) {
+  if (!import_node_path14.default.isAbsolute(targetPath)) {
     res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
     res.end("replacement file path must be absolute");
     return true;
@@ -9012,10 +9074,10 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
   const runtimePackages = new Set(url.searchParams.getAll("runtimePackage"));
   let resolvedProjectRoot;
   if (options.projectRoot) {
-    const lexicalProjectRoot = import_node_path13.default.resolve(options.projectRoot);
+    const lexicalProjectRoot = import_node_path14.default.resolve(options.projectRoot);
     resolvedProjectRoot = await import_promises5.default.realpath(options.projectRoot);
-    const lexicalTarget = import_node_path13.default.relative(lexicalProjectRoot, targetPath);
-    if (lexicalTarget.startsWith("..") || import_node_path13.default.isAbsolute(lexicalTarget)) {
+    const lexicalTarget = import_node_path14.default.relative(lexicalProjectRoot, targetPath);
+    if (lexicalTarget.startsWith("..") || import_node_path14.default.isAbsolute(lexicalTarget)) {
       res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
       res.end("replacement file must be inside the project root");
       return true;
@@ -9031,8 +9093,8 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
     return true;
   }
   if (resolvedProjectRoot) {
-    const relativeTarget = import_node_path13.default.relative(resolvedProjectRoot, resolvedTargetPath);
-    if (relativeTarget.startsWith("..") || import_node_path13.default.isAbsolute(relativeTarget)) {
+    const relativeTarget = import_node_path14.default.relative(resolvedProjectRoot, resolvedTargetPath);
+    if (relativeTarget.startsWith("..") || import_node_path14.default.isAbsolute(relativeTarget)) {
       res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
       res.end("replacement file must be inside the project root");
       return true;
@@ -9494,7 +9556,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
   async startAsync(options) {
     if (this.httpServer || this.wss) return this.effectivePort;
     this.refreshActiveRuntime();
-    this.bootstrapping = !this.activeRuntimeDirPath || !import_fs3.default.existsSync(import_path3.default.join(this.activeRuntimeDirPath, "index.html"));
+    this.bootstrapping = !this.activeRuntimeDirPath || !import_fs2.default.existsSync(import_path2.default.join(this.activeRuntimeDirPath, "index.html"));
     for (let attempt = 0; attempt < this.portFallbackCount; attempt++) {
       const candidate = this.preferredPort + attempt;
       try {
@@ -10166,10 +10228,10 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
       return;
     }
     const root = cameraFixturesDir();
-    const filePath = import_path3.default.join(root, name2);
+    const filePath = import_path2.default.join(root, name2);
     let stats;
     try {
-      stats = import_fs3.default.lstatSync(filePath);
+      stats = import_fs2.default.lstatSync(filePath);
     } catch {
       res.writeHead(404, { ...cors, "Content-Type": "text/plain; charset=utf-8" });
       res.end("not found");
@@ -10180,7 +10242,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
       res.end("forbidden");
       return;
     }
-    const contentType = HTTP_MIME_TYPES[import_path3.default.extname(filePath).toLowerCase()] || "application/octet-stream";
+    const contentType = HTTP_MIME_TYPES[import_path2.default.extname(filePath).toLowerCase()] || "application/octet-stream";
     sendFileWithRanges(req, res, filePath, stats.size, {
       ...cors,
       "Content-Type": contentType
@@ -10214,7 +10276,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
   }
   startRuntimeUpdater() {
     if (!this.shouldWriteLockfile || this.runtimeUpdateTimer) return;
-    if (import_fs3.default.existsSync(import_path3.default.join(rnxHomeDir(), "runtime-update-disabled"))) {
+    if (!automaticPeachUpdatesEnabled()) {
       this.bootstrapping = false;
       if (this.httpServer) this.writeLockfileSnapshot();
       return;
@@ -10230,6 +10292,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
     this.runtimeUpdateTimer.unref();
   }
   runRuntimeUpdate(reason) {
+    if (!automaticPeachUpdatesEnabled()) return Promise.resolve();
     if (this.runtimeUpdateInFlight) return this.runtimeUpdateInFlight;
     this.runtimeUpdateInFlight = (async () => {
       try {
@@ -10556,34 +10619,34 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
         return;
       }
     }
-    const resolved = import_path3.default.resolve(baseDir, "." + rel);
-    const baseWithSep = baseDir.endsWith(import_path3.default.sep) ? baseDir : baseDir + import_path3.default.sep;
+    const resolved = import_path2.default.resolve(baseDir, "." + rel);
+    const baseWithSep = baseDir.endsWith(import_path2.default.sep) ? baseDir : baseDir + import_path2.default.sep;
     if (!resolved.startsWith(baseWithSep) && resolved !== baseDir) {
       res.writeHead(403);
       res.end("forbidden");
       return;
     }
-    import_fs3.default.realpath(resolved, (realErr, realResolved) => {
+    import_fs2.default.realpath(resolved, (realErr, realResolved) => {
       const servePath = realErr ? resolved : realResolved;
-      const servePathWithSep = servePath.endsWith(import_path3.default.sep) ? servePath : servePath + import_path3.default.sep;
+      const servePathWithSep = servePath.endsWith(import_path2.default.sep) ? servePath : servePath + import_path2.default.sep;
       if (!realErr) {
         const realBaseWithSep = (() => {
           try {
-            const rb = import_fs3.default.realpathSync(baseDir);
-            return rb.endsWith(import_path3.default.sep) ? rb : rb + import_path3.default.sep;
+            const rb = import_fs2.default.realpathSync(baseDir);
+            return rb.endsWith(import_path2.default.sep) ? rb : rb + import_path2.default.sep;
           } catch {
             return baseWithSep;
           }
         })();
-        if (!servePathWithSep.startsWith(realBaseWithSep) && servePath + import_path3.default.sep !== realBaseWithSep) {
+        if (!servePathWithSep.startsWith(realBaseWithSep) && servePath + import_path2.default.sep !== realBaseWithSep) {
           res.writeHead(403);
           res.end("forbidden");
           return;
         }
       }
-      import_fs3.default.stat(servePath, (err, stats) => {
+      import_fs2.default.stat(servePath, (err, stats) => {
         if (err || !stats?.isFile()) {
-          const ext2 = import_path3.default.extname(rel).toLowerCase();
+          const ext2 = import_path2.default.extname(rel).toLowerCase();
           if (ext2 && ext2 !== ".html") {
             res.writeHead(404);
             res.end("not found");
@@ -10594,8 +10657,8 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
             res.end("not found");
             return;
           }
-          const indexPath = import_path3.default.join(baseDir, "index.html");
-          import_fs3.default.readFile(indexPath, (err2, data) => {
+          const indexPath = import_path2.default.join(baseDir, "index.html");
+          import_fs2.default.readFile(indexPath, (err2, data) => {
             if (err2) {
               res.writeHead(404);
               res.end("not found");
@@ -10615,7 +10678,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
           });
           return;
         }
-        const ext = import_path3.default.extname(servePath).toLowerCase();
+        const ext = import_path2.default.extname(servePath).toLowerCase();
         const contentType = HTTP_MIME_TYPES[ext] || "application/octet-stream";
         res.writeHead(200, {
           "Content-Type": contentType,
@@ -10626,7 +10689,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
           return;
         }
         if (ext === ".html") {
-          import_fs3.default.readFile(servePath, (readErr, data) => {
+          import_fs2.default.readFile(servePath, (readErr, data) => {
             if (readErr) {
               try {
                 res.end();
@@ -10640,7 +10703,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
           });
           return;
         }
-        const stream = import_fs3.default.createReadStream(servePath);
+        const stream = import_fs2.default.createReadStream(servePath);
         stream.pipe(res);
         stream.on("error", () => {
           try {