sootsim 0.1.305 → 0.1.307

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

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.305 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.307 | (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;
@@ -36,15 +36,33 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var optional_demo_registry_exports = {};
 __export(optional_demo_registry_exports, {
   __withOptionalDemoAppsForTests: () => __withOptionalDemoAppsForTests,
+  findInternalDemoRegistry: () => findInternalDemoRegistry,
   loadOptionalDemoApps: () => loadOptionalDemoApps,
   optionalDemoAppsSync: () => optionalDemoAppsSync
 });
+function findInternalDemoRegistry(startDir) {
+  let dir = startDir;
+  for (let step = 0; step < MAX_ANCESTOR_STEPS; step++) {
+    if ((0, import_node_path2.basename)(dir) === "node_modules") return null;
+    const candidate = (0, import_node_path2.join)(dir, REGISTRY_REPO_PATH);
+    if ((0, import_node_fs.existsSync)(candidate)) return candidate;
+    const parent = (0, import_node_path2.dirname)(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
 async function loadOptionalDemoApps() {
   if (cached) return cached;
+  const registryPath = findInternalDemoRegistry((0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(__sootsim_import_meta_url)));
+  if (!registryPath) {
+    cached = [];
+    return cached;
+  }
   try {
     const mod = await import(
       /* @vite-ignore */
-      REGISTRY_SPECIFIER
+      (0, import_node_url.pathToFileURL)(registryPath).href
     );
     cached = Array.isArray(mod.APPS) ? mod.APPS : [];
   } catch {
@@ -64,11 +82,15 @@ function __withOptionalDemoAppsForTests(apps) {
     }
   };
 }
-var REGISTRY_SPECIFIER, cached;
+var import_node_fs, import_node_path2, import_node_url, REGISTRY_REPO_PATH, MAX_ANCESTOR_STEPS, cached;
 var init_optional_demo_registry = __esm({
   "scripts/optional-demo-registry.ts"() {
     "use strict";
-    REGISTRY_SPECIFIER = "./demo-app-registry.ts";
+    import_node_fs = require("node:fs");
+    import_node_path2 = require("node:path");
+    import_node_url = require("node:url");
+    REGISTRY_REPO_PATH = "packages/sootsim/scripts/demo-app-registry.ts";
+    MAX_ANCESTOR_STEPS = 8;
     cached = null;
   }
 });
@@ -81,9 +103,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_http3 = require("http");
-var import_path3 = __toESM(require("path"), 1);
+var import_path2 = __toESM(require("path"), 1);
 var import_ws2 = require("ws");
 
 // scripts/dev-server-scanner.ts
@@ -146,12 +168,9 @@ function normalizeNativeDevBundleUrl(bundleUrl) {
 // src/settings-bundle.ts
 var import_promises = require("node:fs/promises");
 var import_node_path = require("node:path");
+
+// src/plist.ts
 var import_plist = __toESM(require("@expo/plist"), 1);
-var MAX_PLIST_BYTES = 1048576;
-var MAX_CHILD_DEPTH = 8;
-var MAX_PLIST_FILES = 32;
-var MAX_SPECIFIERS = 512;
-var settingsBundleCache = /* @__PURE__ */ new Map();
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -167,6 +186,19 @@ function resolvePlistParser(value) {
   return typeof nestedParse === "function" ? (source) => Reflect.apply(nestedParse, nested, [source]) : null;
 }
 var parsePlist = resolvePlistParser(import_plist.default);
+function parsePlistSource(source) {
+  return parsePlist?.(source) ?? null;
+}
+
+// src/settings-bundle.ts
+var MAX_PLIST_BYTES = 1048576;
+var MAX_CHILD_DEPTH = 8;
+var MAX_PLIST_FILES = 32;
+var MAX_SPECIFIERS = 512;
+var settingsBundleCache = /* @__PURE__ */ new Map();
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function optionalString(value) {
   return typeof value === "string" ? value : void 0;
 }
@@ -289,12 +321,11 @@ async function settingsBundleFingerprint(bundlePath) {
 }
 async function parsePlistRecord(path9) {
   try {
-    if (!parsePlist) return null;
     const metadata = await (0, import_promises.stat)(path9);
     if (!metadata.isFile() || metadata.size > MAX_PLIST_BYTES) return null;
     const source = await (0, import_promises.readFile)(path9, "utf8");
-    const parsed = parsePlist(source);
-    return isRecord(parsed) ? parsed : null;
+    const parsed = parsePlistSource(source);
+    return isRecord2(parsed) ? parsed : null;
   } catch {
     return null;
   }
@@ -330,7 +361,7 @@ function normalizeMultiValue(raw, key, title) {
   };
 }
 async function normalizeSpecifier(raw, context) {
-  if (!isRecord(raw)) return null;
+  if (!isRecord2(raw)) return null;
   if (context.budget.specifiers >= MAX_SPECIFIERS) return null;
   const type = requiredString(raw.Type);
   if (!type) return null;
@@ -479,7 +510,6 @@ async function readAppSettingsBundle(projectRoot) {
 // scripts/dev-server-scanner.ts
 init_optional_demo_registry();
 var execP = (0, import_util.promisify)(import_child_process.exec);
-void loadOptionalDemoApps();
 var TIMEOUT_MS = 250;
 var MANIFEST_TIMEOUT_MS = 1500;
 var TCP_GATE_MS = 120;
@@ -732,6 +762,7 @@ var knownNonPatched = /* @__PURE__ */ new Set();
 var knownNonExpo = /* @__PURE__ */ new Set();
 var knownOne = /* @__PURE__ */ new Set();
 async function probePort(port, buildIconProxyUrl) {
+  await loadOptionalDemoApps();
   if (!await tcpPing(port)) return null;
   const onePath = `/node_modules/one/metro-entry.bundle?platform=ios&dev=true`;
   const [sootsimRes, statusRes, manifestRes, expoRes] = await Promise.all([
@@ -934,19 +965,19 @@ var SOOTSIM_BRIDGE_SIM_CLOSE_CODE = 4001;
 var SOOTSIM_BRIDGE_SIM_CLOSE_REASON = "sootsim close";
 
 // src/cli-version.ts
-var import_node_fs = require("node:fs");
-var import_node_url = require("node:url");
+var import_node_fs2 = require("node:fs");
+var import_node_url2 = require("node:url");
 var import_meta = {};
 var cached2 = null;
 function getCliVersion() {
   if (cached2 != null) return cached2;
   const candidates = [
-    () => (0, import_node_url.fileURLToPath)(import_meta.resolve("sootsim/package.json")),
-    () => (0, import_node_url.fileURLToPath)(new URL("../package.json", __sootsim_import_meta_url))
+    () => (0, import_node_url2.fileURLToPath)(import_meta.resolve("sootsim/package.json")),
+    () => (0, import_node_url2.fileURLToPath)(new URL("../package.json", __sootsim_import_meta_url))
   ];
   for (const resolve of candidates) {
     try {
-      const version = JSON.parse((0, import_node_fs.readFileSync)(resolve(), "utf8")).version;
+      const version = JSON.parse((0, import_node_fs2.readFileSync)(resolve(), "utf8")).version;
       if (typeof version === "string" && version) {
         cached2 = version;
         return cached2;
@@ -959,9 +990,9 @@ function getCliVersion() {
 }
 
 // src/home-paths.ts
-var import_node_fs2 = __toESM(require("node:fs"), 1);
+var import_node_fs3 = __toESM(require("node:fs"), 1);
 var import_node_os = require("node:os");
-var import_node_path2 = __toESM(require("node:path"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
 var SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
 var ACTIVE_RUNTIME_FILE = "active";
 var DAEMON_LOCKFILE = "daemon.json";
@@ -970,8 +1001,8 @@ var CONFIG_FILE = "config.json";
 var DAEMON_HEARTBEAT_STALE_MS = 3e4;
 function sootsimHomeDir() {
   const override = process.env[SOOTSIM_HOME_ENV];
-  if (override && override.length > 0) return import_node_path2.default.resolve(override);
-  return import_node_path2.default.join((0, import_node_os.homedir)(), ".sootsim");
+  if (override && override.length > 0) return import_node_path3.default.resolve(override);
+  return import_node_path3.default.join((0, import_node_os.homedir)(), ".sootsim");
 }
 function isSootsimDevCheckout() {
   if (process.env.SOOTSIM_FORCE_DAEMON_INSTALL === "1") return false;
@@ -981,45 +1012,45 @@ function isSootsimDevCheckout() {
   const argv1 = process.argv[1];
   if (!argv1) return false;
   try {
-    const real = import_node_fs2.default.realpathSync(argv1);
-    return real.includes(`${import_node_path2.default.sep}packages${import_node_path2.default.sep}sootsim${import_node_path2.default.sep}`);
+    const real = import_node_fs3.default.realpathSync(argv1);
+    return real.includes(`${import_node_path3.default.sep}packages${import_node_path3.default.sep}sootsim${import_node_path3.default.sep}`);
   } catch {
     return false;
   }
 }
 function runtimesDir() {
-  return import_node_path2.default.join(sootsimHomeDir(), "runtimes");
+  return import_node_path3.default.join(sootsimHomeDir(), "runtimes");
 }
 function runtimeDir(version) {
-  return import_node_path2.default.join(runtimesDir(), version);
+  return import_node_path3.default.join(runtimesDir(), version);
 }
 function activeRuntimeFile() {
-  return import_node_path2.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
+  return import_node_path3.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
 }
 function electronDir() {
-  return import_node_path2.default.join(sootsimHomeDir(), "electron");
+  return import_node_path3.default.join(sootsimHomeDir(), "electron");
 }
 function electronUserDataDir() {
-  return import_node_path2.default.join(electronDir(), "userData");
+  return import_node_path3.default.join(electronDir(), "userData");
 }
 function profilesDir() {
-  return import_node_path2.default.join(sootsimHomeDir(), "profiles");
+  return import_node_path3.default.join(sootsimHomeDir(), "profiles");
 }
 function cacheDir() {
-  return import_node_path2.default.join(sootsimHomeDir(), "cache");
+  return import_node_path3.default.join(sootsimHomeDir(), "cache");
 }
 function daemonLockfilePath() {
-  return import_node_path2.default.join(sootsimHomeDir(), DAEMON_LOCKFILE);
+  return import_node_path3.default.join(sootsimHomeDir(), DAEMON_LOCKFILE);
 }
 function devBridgeLockfilePath() {
-  return import_node_path2.default.join(sootsimHomeDir(), DEV_BRIDGE_LOCKFILE);
+  return import_node_path3.default.join(sootsimHomeDir(), DEV_BRIDGE_LOCKFILE);
 }
 function configFilePath() {
-  return import_node_path2.default.join(sootsimHomeDir(), CONFIG_FILE);
+  return import_node_path3.default.join(sootsimHomeDir(), CONFIG_FILE);
 }
 function readSharedConfig() {
   try {
-    const raw = import_node_fs2.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 {
@@ -1037,39 +1068,39 @@ function writeSharedConfig(patch) {
     };
   }
   const tmp = `${configFilePath()}.tmp`;
-  import_node_fs2.default.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}
+  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}
 `, "utf8");
-  import_node_fs2.default.renameSync(tmp, configFilePath());
+  import_node_fs3.default.renameSync(tmp, configFilePath());
   return next;
 }
 function runtimeUpgradeNoticePath() {
-  return import_node_path2.default.join(sootsimHomeDir(), "runtime-upgraded.json");
+  return import_node_path3.default.join(sootsimHomeDir(), "runtime-upgraded.json");
 }
 function writeRuntimeUpgradeNotice(notice) {
   ensureSootsimHome();
   const tmp = `${runtimeUpgradeNoticePath()}.tmp`;
-  import_node_fs2.default.writeFileSync(tmp, `${JSON.stringify(notice)}
+  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(notice)}
 `, "utf8");
-  import_node_fs2.default.renameSync(tmp, runtimeUpgradeNoticePath());
+  import_node_fs3.default.renameSync(tmp, runtimeUpgradeNoticePath());
 }
 function ensureSootsimHome() {
-  import_node_fs2.default.mkdirSync(sootsimHomeDir(), { recursive: true });
-  import_node_fs2.default.mkdirSync(runtimesDir(), { recursive: true });
-  import_node_fs2.default.mkdirSync(electronDir(), { recursive: true });
-  import_node_fs2.default.mkdirSync(profilesDir(), { recursive: true });
-  import_node_fs2.default.mkdirSync(cacheDir(), { recursive: true });
+  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 readActiveRuntime() {
   try {
-    const value = import_node_fs2.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_fs2.default.mkdirSync(runtimesDir(), { recursive: true });
-  import_node_fs2.default.writeFileSync(activeRuntimeFile(), `${version}
+  import_node_fs3.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_node_fs3.default.writeFileSync(activeRuntimeFile(), `${version}
 `, "utf8");
 }
 function activeRuntimeDir() {
@@ -1077,7 +1108,7 @@ function activeRuntimeDir() {
   if (!version) return null;
   const dir = runtimeDir(version);
   try {
-    if (import_node_fs2.default.statSync(dir).isDirectory()) return dir;
+    if (import_node_fs3.default.statSync(dir).isDirectory()) return dir;
   } catch {
   }
   return null;
@@ -1085,10 +1116,10 @@ function activeRuntimeDir() {
 var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
 function readDaemonLockfile() {
   try {
-    const fd = import_node_fs2.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_fs2.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"))) {
@@ -1096,7 +1127,7 @@ function readDaemonLockfile() {
       }
       return null;
     } finally {
-      import_node_fs2.default.closeSync(fd);
+      import_node_fs3.default.closeSync(fd);
     }
   } catch {
     return null;
@@ -1115,16 +1146,16 @@ function isDaemonLockfileFresh(lock, now = Date.now()) {
 function writeDaemonLockfile(data) {
   ensureSootsimHome();
   const tmp = `${daemonLockfilePath()}.tmp`;
-  import_node_fs2.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
 `, "utf8");
-  import_node_fs2.default.renameSync(tmp, daemonLockfilePath());
+  import_node_fs3.default.renameSync(tmp, daemonLockfilePath());
 }
 function writeDevBridgeLockfile(data) {
   ensureSootsimHome();
   const tmp = `${devBridgeLockfilePath()}.tmp`;
-  import_node_fs2.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
 `, "utf8");
-  import_node_fs2.default.renameSync(tmp, devBridgeLockfilePath());
+  import_node_fs3.default.renameSync(tmp, devBridgeLockfilePath());
 }
 function claimDaemonLockfile(data) {
   ensureSootsimHome();
@@ -1137,13 +1168,13 @@ function claimDaemonLockfile(data) {
 }
 function removeDaemonLockfile() {
   try {
-    import_node_fs2.default.unlinkSync(daemonLockfilePath());
+    import_node_fs3.default.unlinkSync(daemonLockfilePath());
   } catch {
   }
 }
 function removeDevBridgeLockfile() {
   try {
-    import_node_fs2.default.unlinkSync(devBridgeLockfilePath());
+    import_node_fs3.default.unlinkSync(devBridgeLockfilePath());
   } catch {
   }
 }
@@ -1156,27 +1187,27 @@ var import_url = require("url");
 // ../contrast-runtime-delivery/src/index.ts
 var import_node_child_process = require("node:child_process");
 var import_node_crypto = __toESM(require("node:crypto"), 1);
-var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_fs5 = __toESM(require("node:fs"), 1);
 var import_node_os2 = __toESM(require("node:os"), 1);
-var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_path5 = __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_fs3 = __toESM(require("node:fs"), 1);
-var import_node_path3 = __toESM(require("node:path"), 1);
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_path4 = __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_fs3.default.readdirSync(product.runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
+    return import_node_fs4.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_path3.default.posix.basename(product.tarballPath(version));
+  return import_node_path4.default.posix.basename(product.tarballPath(version));
 }
 function compareSemver(a, b) {
   const parse = (v) => {
@@ -1206,7 +1237,7 @@ function createRuntimeDelivery(product) {
   function readConfig() {
     try {
       const parsed = JSON.parse(
-        import_node_fs4.default.readFileSync(product.configFile(), "utf8")
+        import_node_fs5.default.readFileSync(product.configFile(), "utf8")
       );
       return parsed && typeof parsed === "object" ? parsed : {};
     } catch {
@@ -1273,7 +1304,7 @@ function createRuntimeDelivery(product) {
     const setActive = opts.setActive !== false;
     const protectVersions = [version, ...opts.protectVersions ?? []];
     pruneLocalRetention({ protectVersions });
-    if (!opts.force && import_node_fs4.default.existsSync(import_node_path4.default.join(destDir, product.installedMarker))) {
+    if (!opts.force && import_node_fs5.default.existsSync(import_node_path5.default.join(destDir, product.installedMarker))) {
       if (setActive) product.writeActiveRuntime(version);
       pruneLocalRetention({ protectVersions });
       return {
@@ -1287,18 +1318,18 @@ function createRuntimeDelivery(product) {
       };
     }
     const tarUrl = entry.tarball || tarballUrl(version, cdnOrigin);
-    const downloadDir = import_node_fs4.default.mkdtempSync(
-      import_node_path4.default.join(import_node_os2.default.tmpdir(), `${product.id}-runtime-download-`)
+    const downloadDir = import_node_fs5.default.mkdtempSync(
+      import_node_path5.default.join(import_node_os2.default.tmpdir(), `${product.id}-runtime-download-`)
     );
-    const runtimeArchivePath = import_node_path4.default.join(
+    const runtimeArchivePath = import_node_path5.default.join(
       downloadDir,
       runtimeTarballCacheName(product, version)
     );
-    const tmpDir = import_node_path4.default.join(
-      import_node_path4.default.dirname(destDir),
+    const tmpDir = import_node_path5.default.join(
+      import_node_path5.default.dirname(destDir),
       `.installing-${version}-${process.pid}`
     );
-    import_node_fs4.default.rmSync(tmpDir, { recursive: true, force: true });
+    import_node_fs5.default.rmSync(tmpDir, { recursive: true, force: true });
     try {
       process.stderr.write(`${product.id}: downloading runtime ${version}\u2026
 `);
@@ -1311,20 +1342,20 @@ function createRuntimeDelivery(product) {
           `sha256 mismatch for runtime ${version}: expected ${entry.sha256}, actual ${actualSha}`
         );
       }
-      import_node_fs4.default.mkdirSync(tmpDir, { recursive: true });
+      import_node_fs5.default.mkdirSync(tmpDir, { recursive: true });
       await extractTarball(runtimeArchivePath, tmpDir);
-      if (!import_node_fs4.default.existsSync(import_node_path4.default.join(tmpDir, product.installedMarker))) {
+      if (!import_node_fs5.default.existsSync(import_node_path5.default.join(tmpDir, product.installedMarker))) {
         throw new Error(
           `extracted tarball for runtime ${version} is missing ${product.installedMarker}`
         );
       }
-      import_node_fs4.default.rmSync(destDir, { recursive: true, force: true });
-      import_node_fs4.default.renameSync(tmpDir, destDir);
+      import_node_fs5.default.rmSync(destDir, { recursive: true, force: true });
+      import_node_fs5.default.renameSync(tmpDir, destDir);
     } catch (err) {
-      import_node_fs4.default.rmSync(tmpDir, { recursive: true, force: true });
+      import_node_fs5.default.rmSync(tmpDir, { recursive: true, force: true });
       throw err;
     } finally {
-      import_node_fs4.default.rmSync(downloadDir, { recursive: true, force: true });
+      import_node_fs5.default.rmSync(downloadDir, { recursive: true, force: true });
     }
     if (setActive) product.writeActiveRuntime(version);
     pruneLocalRetention({ protectVersions });
@@ -1346,8 +1377,8 @@ function createRuntimeDelivery(product) {
     const pin = resolvePin();
     if (pin) {
       const activeVersion2 = product.readActiveRuntime();
-      const pinInstalled = import_node_fs4.default.existsSync(
-        import_node_path4.default.join(product.runtimeDir(pin), product.installedMarker)
+      const pinInstalled = import_node_fs5.default.existsSync(
+        import_node_path5.default.join(product.runtimeDir(pin), product.installedMarker)
       );
       if (activeVersion2 === pin && pinInstalled) {
         return {
@@ -1396,7 +1427,7 @@ function createRuntimeDelivery(product) {
     }
     const activeVersion = product.readActiveRuntime();
     const activeDir = activeVersion ? product.runtimeDir(activeVersion) : null;
-    const activeInstalled = activeDir ? import_node_fs4.default.existsSync(import_node_path4.default.join(activeDir, product.installedMarker)) : false;
+    const activeInstalled = activeDir ? import_node_fs5.default.existsSync(import_node_path5.default.join(activeDir, product.installedMarker)) : false;
     const shouldInstall = !activeVersion || !activeInstalled || compareSemver(latestVersion, activeVersion) > 0;
     if (!shouldInstall) {
       return {
@@ -1468,12 +1499,12 @@ function createRuntimeDelivery(product) {
     let removeCacheFiles = [];
     if (markerOffset >= 0) {
       try {
-        removeCacheFiles = import_node_fs4.default.readdirSync(product.cacheDir(), { withFileTypes: true }).filter((entry) => {
+        removeCacheFiles = import_node_fs5.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_path4.default.join(product.cacheDir(), entry.name)).sort();
+        }).map((entry) => import_node_path5.default.join(product.cacheDir(), entry.name)).sort();
       } catch {
       }
     }
@@ -1488,10 +1519,10 @@ function createRuntimeDelivery(product) {
   function pruneLocalRetention(opts = {}) {
     const plan = planLocalRetention(opts);
     for (const version of plan.removeVersions) {
-      import_node_fs4.default.rmSync(product.runtimeDir(version), { recursive: true, force: true });
+      import_node_fs5.default.rmSync(product.runtimeDir(version), { recursive: true, force: true });
     }
     for (const cacheFile of plan.removeCacheFiles) {
-      import_node_fs4.default.rmSync(cacheFile, { force: true });
+      import_node_fs5.default.rmSync(cacheFile, { force: true });
     }
     return plan;
   }
@@ -1517,17 +1548,17 @@ async function downloadToFile(url, destPath) {
   if (!res.ok || !res.body) {
     throw new Error(`download failed: ${res.status} ${res.statusText} (${url})`);
   }
-  import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(destPath), { recursive: true });
+  import_node_fs5.default.mkdirSync(import_node_path5.default.dirname(destPath), { recursive: true });
   const tmp = `${destPath}.partial`;
   try {
     await (0, import_promises3.pipeline)(
       import_node_stream.Readable.fromWeb(res.body),
-      import_node_fs4.default.createWriteStream(tmp)
+      import_node_fs5.default.createWriteStream(tmp)
     );
-    import_node_fs4.default.renameSync(tmp, destPath);
+    import_node_fs5.default.renameSync(tmp, destPath);
   } catch (err) {
     try {
-      import_node_fs4.default.unlinkSync(tmp);
+      import_node_fs5.default.unlinkSync(tmp);
     } catch {
     }
     throw err;
@@ -1536,7 +1567,7 @@ async function downloadToFile(url, destPath) {
 function sha256File(filePath) {
   return new Promise((resolve, reject) => {
     const hash = import_node_crypto.default.createHash("sha256");
-    const stream = import_node_fs4.default.createReadStream(filePath);
+    const stream = import_node_fs5.default.createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -1628,14 +1659,14 @@ var SOOTSIM_RUNTIME_PRODUCT = {
 var sootsimRuntime = createRuntimeDelivery(SOOTSIM_RUNTIME_PRODUCT);
 
 // src/host/agent-host.ts
-var import_node_fs7 = __toESM(require("node:fs"), 1);
-var import_node_path7 = __toESM(require("node:path"), 1);
+var import_node_fs8 = __toESM(require("node:fs"), 1);
+var import_node_path8 = __toESM(require("node:path"), 1);
 
 // src/agent-sessions.ts
 var import_node_child_process2 = require("node:child_process");
 var import_node_crypto3 = require("node:crypto");
-var import_node_fs6 = __toESM(require("node:fs"), 1);
-var import_node_path6 = __toESM(require("node:path"), 1);
+var import_node_fs7 = __toESM(require("node:fs"), 1);
+var import_node_path7 = __toESM(require("node:path"), 1);
 var import_node_readline = __toESM(require("node:readline"), 1);
 
 // src/agent-events.ts
@@ -1679,8 +1710,8 @@ function encodeAgentPromptEnvelope(input) {
 
 // src/attached-projects.ts
 var import_node_crypto2 = require("node:crypto");
-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);
 var overrideDir = null;
 function userDataDir() {
   if (overrideDir) return overrideDir;
@@ -1692,7 +1723,7 @@ function getUserDataDir() {
   return userDataDir();
 }
 function storeFile() {
-  return import_node_path5.default.join(userDataDir(), "attached-projects.json");
+  return import_node_path6.default.join(userDataDir(), "attached-projects.json");
 }
 function cloneEmpty() {
   return {
@@ -1706,7 +1737,7 @@ function loadStore() {
   const file = storeFile();
   let raw;
   try {
-    raw = import_node_fs5.default.readFileSync(file, "utf8");
+    raw = import_node_fs6.default.readFileSync(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return cloneEmpty();
     throw err;
@@ -1723,7 +1754,7 @@ function loadStore() {
   } catch (err) {
     const quarantine = `${file}.corrupt-${Date.now()}`;
     try {
-      import_node_fs5.default.renameSync(file, quarantine);
+      import_node_fs6.default.renameSync(file, quarantine);
       console.warn(
         `[sootsim] attached-projects.json was unparseable; quarantined to ${quarantine}. original error: ${err.message}`
       );
@@ -1734,16 +1765,16 @@ function loadStore() {
 }
 function writeStore(store) {
   const file = storeFile();
-  import_node_fs5.default.mkdirSync(import_node_path5.default.dirname(file), { recursive: true });
+  import_node_fs6.default.mkdirSync(import_node_path6.default.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-  const fd = import_node_fs5.default.openSync(tmp, "w", 384);
+  const fd = import_node_fs6.default.openSync(tmp, "w", 384);
   try {
-    import_node_fs5.default.writeFileSync(fd, JSON.stringify(store, null, 2));
-    import_node_fs5.default.fsyncSync(fd);
+    import_node_fs6.default.writeFileSync(fd, JSON.stringify(store, null, 2));
+    import_node_fs6.default.fsyncSync(fd);
   } finally {
-    import_node_fs5.default.closeSync(fd);
+    import_node_fs6.default.closeSync(fd);
   }
-  import_node_fs5.default.renameSync(tmp, file);
+  import_node_fs6.default.renameSync(tmp, file);
 }
 function mutateStore(fn) {
   const store = loadStore();
@@ -1752,13 +1783,13 @@ function mutateStore(fn) {
   return store;
 }
 function projectIdForCwd(cwd) {
-  return (0, import_node_crypto2.createHash)("sha256").update(import_node_path5.default.resolve(cwd)).digest("hex").slice(0, 16);
+  return (0, import_node_crypto2.createHash)("sha256").update(import_node_path6.default.resolve(cwd)).digest("hex").slice(0, 16);
 }
 function newSessionId() {
   return `s_${(0, import_node_crypto2.randomBytes)(10).toString("hex")}`;
 }
 function upsertProject(input) {
-  const cwd = import_node_path5.default.resolve(input.cwd);
+  const cwd = import_node_path6.default.resolve(input.cwd);
   const id = projectIdForCwd(cwd);
   let result;
   mutateStore((store) => {
@@ -1784,7 +1815,7 @@ function upsertProject(input) {
     const now = Date.now();
     const created = {
       id,
-      name: input.name ?? import_node_path5.default.basename(cwd),
+      name: input.name ?? import_node_path6.default.basename(cwd),
       cwd,
       repoRoot: input.repoRoot,
       sourceRoots: input.sourceRoots ?? [cwd],
@@ -1930,8 +1961,8 @@ async function seedFromDemoAppRegistry() {
   if (apps.length === 0) return;
   mutateStore((store) => {
     for (const app of apps) {
-      if (!import_node_fs5.default.existsSync(app.dir)) continue;
-      const cwd = import_node_path5.default.resolve(app.dir);
+      if (!import_node_fs6.default.existsSync(app.dir)) continue;
+      const cwd = import_node_path6.default.resolve(app.dir);
       const id = projectIdForCwd(cwd);
       if (store.attachedProjects.some((p) => p.id === id)) continue;
       const now = Date.now();
@@ -1955,16 +1986,16 @@ async function seedFromDemoAppRegistry() {
 
 // src/agent-sessions.ts
 function sessionDir(sessionId) {
-  return import_node_path6.default.join(getUserDataDir(), "sessions", sessionId);
+  return import_node_path7.default.join(getUserDataDir(), "sessions", sessionId);
 }
 function promptFifoPath(sessionId) {
-  return import_node_path6.default.join(sessionDir(sessionId), "prompt.in");
+  return import_node_path7.default.join(sessionDir(sessionId), "prompt.in");
 }
 function eventsFifoPath(sessionId) {
-  return import_node_path6.default.join(sessionDir(sessionId), "events.out");
+  return import_node_path7.default.join(sessionDir(sessionId), "events.out");
 }
 function transcriptPath(sessionId) {
-  return import_node_path6.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
+  return import_node_path7.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
 }
 function pidIsAlive(pid, sessionId) {
   if (!pid) return false;
@@ -1974,7 +2005,7 @@ function pidIsAlive(pid, sessionId) {
     return false;
   }
   if (sessionId) {
-    if (!import_node_fs6.default.existsSync(sessionDir(sessionId))) return false;
+    if (!import_node_fs7.default.existsSync(sessionDir(sessionId))) return false;
   }
   return true;
 }
@@ -1986,11 +2017,11 @@ function resolveSootsimInvocation() {
     const resourcesPath = process.resourcesPath;
     if (resourcesPath) {
       const candidates = [
-        import_node_path6.default.join(resourcesPath, "bin", "sootsim"),
-        import_node_path6.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
+        import_node_path7.default.join(resourcesPath, "bin", "sootsim"),
+        import_node_path7.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
       ];
       for (const c of candidates) {
-        if (import_node_fs6.default.existsSync(c)) return { cmd: c, prefixArgs: [] };
+        if (import_node_fs7.default.existsSync(c)) return { cmd: c, prefixArgs: [] };
       }
     }
   }
@@ -2013,15 +2044,15 @@ function tryWorkspaceSootsim() {
     const sootsimDir = resolveSootsimPackageDir();
     if (!sootsimDir) return null;
     const binaryName = `sootsim-${process.platform}-${process.arch}`;
-    const distBinary = import_node_path6.default.join(sootsimDir, "dist-bin", binaryName);
-    if (import_node_fs6.default.existsSync(distBinary)) return { cmd: distBinary, prefixArgs: [] };
-    const distBin = import_node_path6.default.join(sootsimDir, "dist-cli", "bin.js");
-    if (import_node_fs6.default.existsSync(distBin)) {
+    const distBinary = import_node_path7.default.join(sootsimDir, "dist-bin", binaryName);
+    if (import_node_fs7.default.existsSync(distBinary)) return { cmd: distBinary, prefixArgs: [] };
+    const distBin = import_node_path7.default.join(sootsimDir, "dist-cli", "bin.js");
+    if (import_node_fs7.default.existsSync(distBin)) {
       try {
-        const src = import_node_path6.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
-        if (import_node_fs6.default.existsSync(src)) {
-          const srcMtime = import_node_fs6.default.statSync(src).mtimeMs;
-          const buildMtime = import_node_fs6.default.statSync(distBin).mtimeMs;
+        const src = import_node_path7.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 (buildMtime < srcMtime) {
             console.warn(
               `[sootsim] dist-cli/bin.js is older than agent-wrapper.ts \u2014 rebuild with \`bun run --cwd packages/sootsim build:cli\`.`
@@ -2040,22 +2071,22 @@ function tryWorkspaceSootsim() {
 function resolveSootsimPackageDir() {
   try {
     const resolved = require.resolve("sootsim/package.json");
-    return import_node_path6.default.dirname(resolved);
+    return import_node_path7.default.dirname(resolved);
   } catch {
   }
   const here = fileFromImportMeta();
   if (!here) return null;
-  let cur = import_node_path6.default.dirname(here);
+  let cur = import_node_path7.default.dirname(here);
   for (let i = 0; i < 8; i++) {
-    const pkg = import_node_path6.default.join(cur, "package.json");
+    const pkg = import_node_path7.default.join(cur, "package.json");
     try {
-      if (import_node_fs6.default.existsSync(pkg)) {
-        const parsed = JSON.parse(import_node_fs6.default.readFileSync(pkg, "utf8"));
+      if (import_node_fs7.default.existsSync(pkg)) {
+        const parsed = JSON.parse(import_node_fs7.default.readFileSync(pkg, "utf8"));
         if (parsed.name === "sootsim") return cur;
       }
     } catch {
     }
-    const parent = import_node_path6.default.dirname(cur);
+    const parent = import_node_path7.default.dirname(cur);
     if (parent === cur) break;
     cur = parent;
   }
@@ -2071,28 +2102,28 @@ function fileFromImportMeta() {
   }
 }
 async function withStartLock(projectId, provider, fn) {
-  const lockDir = import_node_path6.default.join(getUserDataDir(), "locks");
-  import_node_fs6.default.mkdirSync(lockDir, { recursive: true });
+  const lockDir = import_node_path7.default.join(getUserDataDir(), "locks");
+  import_node_fs7.default.mkdirSync(lockDir, { recursive: true });
   try {
-    import_node_fs6.default.chmodSync(lockDir, 448);
+    import_node_fs7.default.chmodSync(lockDir, 448);
   } catch {
   }
-  const lockPath = import_node_path6.default.join(lockDir, `start-${projectId}-${provider}.lock`);
+  const lockPath = import_node_path7.default.join(lockDir, `start-${projectId}-${provider}.lock`);
   const deadline = Date.now() + 4e3;
   let fd = null;
   while (fd === null) {
     try {
-      fd = import_node_fs6.default.openSync(
+      fd = import_node_fs7.default.openSync(
         lockPath,
-        import_node_fs6.constants.O_WRONLY | import_node_fs6.constants.O_CREAT | import_node_fs6.constants.O_EXCL,
+        import_node_fs7.constants.O_WRONLY | import_node_fs7.constants.O_CREAT | import_node_fs7.constants.O_EXCL,
         384
       );
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       try {
-        const stale = Number(import_node_fs6.default.readFileSync(lockPath, "utf8").trim());
+        const stale = Number(import_node_fs7.default.readFileSync(lockPath, "utf8").trim());
         if (stale && !isProcessAlive(stale)) {
-          import_node_fs6.default.unlinkSync(lockPath);
+          import_node_fs7.default.unlinkSync(lockPath);
           continue;
         }
       } catch {
@@ -2106,15 +2137,15 @@ async function withStartLock(projectId, provider, fn) {
     }
   }
   try {
-    import_node_fs6.default.writeFileSync(fd, String(process.pid));
+    import_node_fs7.default.writeFileSync(fd, String(process.pid));
     return await fn();
   } finally {
     try {
-      import_node_fs6.default.closeSync(fd);
+      import_node_fs7.default.closeSync(fd);
     } catch {
     }
     try {
-      import_node_fs6.default.unlinkSync(lockPath);
+      import_node_fs7.default.unlinkSync(lockPath);
     } catch {
     }
   }
@@ -2128,25 +2159,25 @@ function isProcessAlive(pid) {
   }
 }
 function mkfifoSync(p) {
-  const parent = import_node_path6.default.dirname(p);
-  import_node_fs6.default.mkdirSync(parent, { recursive: true });
+  const parent = import_node_path7.default.dirname(p);
+  import_node_fs7.default.mkdirSync(parent, { recursive: true });
   try {
-    import_node_fs6.default.chmodSync(parent, 448);
+    import_node_fs7.default.chmodSync(parent, 448);
   } catch {
   }
-  if (import_node_fs6.default.existsSync(p)) {
+  if (import_node_fs7.default.existsSync(p)) {
     try {
-      const stat2 = import_node_fs6.default.statSync(p);
+      const stat2 = import_node_fs7.default.statSync(p);
       if (stat2.isFIFO()) {
         try {
-          import_node_fs6.default.chmodSync(p, 384);
+          import_node_fs7.default.chmodSync(p, 384);
         } catch {
         }
         return;
       }
-      import_node_fs6.default.unlinkSync(p);
+      import_node_fs7.default.unlinkSync(p);
     } catch {
-      import_node_fs6.default.unlinkSync(p);
+      import_node_fs7.default.unlinkSync(p);
     }
   }
   const result = (0, import_node_child_process2.spawnSync)("mkfifo", ["-m", "600", p]);
@@ -2193,10 +2224,10 @@ async function startSession(opts) {
     const transcript = transcriptPath(session.id);
     mkfifoSync(promptIn);
     mkfifoSync(eventsOut);
-    const transcriptDir = import_node_path6.default.dirname(transcript);
-    import_node_fs6.default.mkdirSync(transcriptDir, { recursive: true });
+    const transcriptDir = import_node_path7.default.dirname(transcript);
+    import_node_fs7.default.mkdirSync(transcriptDir, { recursive: true });
     try {
-      import_node_fs6.default.chmodSync(transcriptDir, 448);
+      import_node_fs7.default.chmodSync(transcriptDir, 448);
     } catch {
     }
     const { cmd, prefixArgs } = resolveSootsimInvocation();
@@ -2247,7 +2278,7 @@ async function startSession(opts) {
         }
       }
       try {
-        import_node_fs6.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
+        import_node_fs7.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
       } catch {
       }
       updateSessionStatus(session.id, { status: "ended" });
@@ -2275,18 +2306,18 @@ async function sendPrompt(sessionId, prompt) {
     );
   }
   const fifo = promptFifoPath(sessionId);
-  if (!import_node_fs6.default.existsSync(fifo)) {
+  if (!import_node_fs7.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `prompt FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs6.default.openSync(fifo, import_node_fs6.constants.O_WRONLY);
+  const fd = import_node_fs7.default.openSync(fifo, import_node_fs7.constants.O_WRONLY);
   try {
     const wireText = encodeAgentPromptEnvelope(prompt);
     if (!wireText) {
       throw new AgentSessionError("EMPTY_PROMPT", "prompt text is empty");
     }
-    import_node_fs6.default.writeSync(fd, wireText + "\n");
+    import_node_fs7.default.writeSync(fd, wireText + "\n");
   } finally {
-    import_node_fs6.default.closeSync(fd);
+    import_node_fs7.default.closeSync(fd);
   }
   updateSessionStatus(sessionId, {
     lastPrompt: prompt.displayText ?? prompt.text,
@@ -2308,7 +2339,7 @@ async function endSession(sessionId) {
   const base = getUserDataDir();
   if (dir.startsWith(base)) {
     try {
-      import_node_fs6.default.rmSync(dir, { recursive: true, force: true });
+      import_node_fs7.default.rmSync(dir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -2316,11 +2347,11 @@ async function endSession(sessionId) {
 }
 function subscribeEvents(sessionId, onEvent) {
   const fifo = eventsFifoPath(sessionId);
-  if (!import_node_fs6.default.existsSync(fifo)) {
+  if (!import_node_fs7.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `events FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs6.default.openSync(fifo, import_node_fs6.constants.O_RDWR);
-  const stream = import_node_fs6.default.createReadStream("", { fd, autoClose: true });
+  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 rl = import_node_readline.default.createInterface({ input: stream, crlfDelay: Infinity });
   rl.on("line", (line) => {
     const event = parseAgentEventLine(line);
@@ -2331,7 +2362,7 @@ function subscribeEvents(sessionId, onEvent) {
     if (closed) return;
     closed = true;
     try {
-      import_node_fs6.default.writeSync(fd, "\n");
+      import_node_fs7.default.writeSync(fd, "\n");
     } catch {
     }
     try {
@@ -2345,7 +2376,7 @@ function subscribeEvents(sessionId, onEvent) {
   };
 }
 async function waitForFirstEvent(fifo, predicate, timeoutMs) {
-  const fd = import_node_fs6.default.openSync(fifo, import_node_fs6.constants.O_RDWR | import_node_fs6.constants.O_NONBLOCK);
+  const fd = import_node_fs7.default.openSync(fifo, import_node_fs7.constants.O_RDWR | import_node_fs7.constants.O_NONBLOCK);
   const buf = Buffer.alloc(8192);
   let leftover = "";
   const deadline = Date.now() + timeoutMs;
@@ -2353,7 +2384,7 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     while (Date.now() < deadline) {
       let n = 0;
       try {
-        n = import_node_fs6.default.readSync(fd, buf, 0, buf.length, null);
+        n = import_node_fs7.default.readSync(fd, buf, 0, buf.length, null);
       } catch (err) {
         if (err.code !== "EAGAIN") throw err;
         n = 0;
@@ -2373,7 +2404,7 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     }
     return null;
   } finally {
-    import_node_fs6.default.closeSync(fd);
+    import_node_fs7.default.closeSync(fd);
   }
 }
 
@@ -2651,7 +2682,7 @@ var AgentHost = class {
     );
     const project = upsertProject({
       cwd: match.cwd,
-      name: match.projectName ?? import_node_path7.default.basename(match.cwd),
+      name: match.projectName ?? import_node_path8.default.basename(match.cwd),
       preferredProvider: input.provider ?? existing?.preferredProvider,
       sourceRoots: existing?.sourceRoots ?? [match.cwd],
       knownBundleUrls,
@@ -2662,18 +2693,18 @@ var AgentHost = class {
   }
   getTranscript(sessionId) {
     const p = transcriptPath(sessionId);
-    if (!import_node_fs7.default.existsSync(p)) {
+    if (!import_node_fs8.default.existsSync(p)) {
       return { error: "transcript not found", code: "NO_TRANSCRIPT" };
     }
-    return import_node_fs7.default.readFileSync(p, "utf8");
+    return import_node_fs8.default.readFileSync(p, "utf8");
   }
   getPaths() {
     const dir = getUserDataDir();
     return {
       userDataDir: dir,
-      storeFile: import_node_path7.default.join(dir, "attached-projects.json"),
-      sessionsDir: import_node_path7.default.join(dir, "sessions"),
-      transcriptsDir: import_node_path7.default.join(dir, "transcripts")
+      storeFile: import_node_path8.default.join(dir, "attached-projects.json"),
+      sessionsDir: import_node_path8.default.join(dir, "sessions"),
+      transcriptsDir: import_node_path8.default.join(dir, "transcripts")
     };
   }
   // --- subscription management ---
@@ -3294,86 +3325,9 @@ function handleAppApiRequest(req, res) {
 
 // src/host/open-url.ts
 var import_child_process2 = require("child_process");
-var import_fs2 = require("fs");
-var import_os = require("os");
-var import_path2 = require("path");
-var MAC_CHROMIUM_CANDIDATES = [
-  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
-  "~/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
-  "/Applications/Chromium.app/Contents/MacOS/Chromium",
-  "~/Applications/Chromium.app/Contents/MacOS/Chromium",
-  "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
-  "~/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
-  "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
-  "~/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
-  "/Applications/Arc.app/Contents/MacOS/Arc",
-  "~/Applications/Arc.app/Contents/MacOS/Arc"
-];
-var LINUX_CHROMIUM_CANDIDATES = [
-  "/usr/bin/google-chrome",
-  "/usr/bin/chromium",
-  "/usr/bin/chromium-browser",
-  "/usr/bin/microsoft-edge",
-  "/usr/bin/brave-browser",
-  "/snap/bin/chromium"
-];
-var WINDOWS_CHROMIUM_CANDIDATES = [
-  "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
-  "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
-  "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
-  "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
-  "C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe",
-  "C:\\Program Files (x86)\\BraveSoftware\\Brave-Browser\\Application\\brave.exe"
-];
-var UNIX_CHROMIUM_COMMANDS = [
-  "google-chrome",
-  "chromium",
-  "chromium-browser",
-  "microsoft-edge",
-  "brave-browser"
-];
-var WINDOWS_CHROMIUM_COMMANDS = ["chrome", "msedge", "brave"];
-function expandHome(candidate) {
-  return candidate.startsWith("~/") ? (0, import_path2.join)((0, import_os.homedir)(), candidate.slice(2)) : candidate;
-}
-function firstExisting(candidates) {
-  for (const candidate of candidates) {
-    const expanded = expandHome(candidate);
-    if ((0, import_fs2.existsSync)(expanded)) return expanded;
-  }
-  return null;
-}
-function lookupExecutable(command, platform) {
-  try {
-    const tool = platform === "win32" ? "where" : "which";
-    const out = (0, import_child_process2.execFileSync)(tool, [command], {
-      encoding: "utf8",
-      timeout: 1500,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-    return out ? out.split(/\r?\n/)[0] : null;
-  } catch {
-    return null;
-  }
-}
-function resolveChromiumBinary(platform = process.platform) {
-  const envCandidate = process.env.CHROME_PATH || process.env.CHROMIUM_PATH;
-  if (envCandidate && (0, import_fs2.existsSync)(envCandidate)) return envCandidate;
-  const direct = platform === "darwin" ? firstExisting(MAC_CHROMIUM_CANDIDATES) : platform === "win32" ? firstExisting(WINDOWS_CHROMIUM_CANDIDATES) : firstExisting(LINUX_CHROMIUM_CANDIDATES);
-  if (direct) return direct;
-  const commands = platform === "win32" ? WINDOWS_CHROMIUM_COMMANDS : UNIX_CHROMIUM_COMMANDS;
-  for (const command of commands) {
-    const found = lookupExecutable(command, platform);
-    if (found) return found;
-  }
-  return null;
-}
 function buildOpenUrlCommand(url, options = {}) {
   if (!url) throw new Error("openUrl requires a url");
   const platform = options.platform ?? process.platform;
-  if (options.newWindow) {
-    return buildChromiumUrlCommand(url, { ...options, platform, newWindow: true });
-  }
   if (platform === "darwin") {
     return {
       command: "open",
@@ -3394,25 +3348,6 @@ function buildOpenUrlCommand(url, options = {}) {
     via: "system"
   };
 }
-function buildChromiumUrlCommand(url, options = {}) {
-  if (!url) throw new Error("openUrl requires a url");
-  const platform = options.platform ?? process.platform;
-  const chromiumBinary = "chromiumBinary" in options ? options.chromiumBinary : resolveChromiumBinary(platform);
-  if (!chromiumBinary) {
-    throw new Error("browser launch requires Chrome, Chromium, Edge, Brave, or Arc");
-  }
-  const args = [];
-  if (options.newWindow !== false) {
-    args.push("--new-window");
-  }
-  args.push(url);
-  return {
-    command: chromiumBinary,
-    args,
-    via: "chromium",
-    target: chromiumBinary
-  };
-}
 async function spawnLaunch(command, args, detached) {
   return new Promise((resolve, reject) => {
     const child = (0, import_child_process2.spawn)(command, args, {
@@ -4157,21 +4092,6 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
               }
               return;
             }
-            if (msg.type === "bridge:open") {
-              if (typeof msg.url !== "string" || !msg.url) {
-                throw new Error("bridge:open requires a url");
-              }
-              await this.openUrl(msg.url, { newWindow: msg.newWindow === true });
-              if (ws.readyState === import_ws2.WebSocket.OPEN) {
-                ws.send(
-                  JSON.stringify({
-                    id: msg.id,
-                    result: { ok: true, url: msg.url }
-                  })
-                );
-              }
-              return;
-            }
             if (msg.type === "bridge:claim") {
               const targetSim2 = await this.waitForSim(msg.simId);
               const outcome = this.tryAcquireLease(ws, targetSim2, {
@@ -4482,7 +4402,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
   }
   startRuntimeUpdater() {
     if (!this.shouldWriteLockfile || this.runtimeUpdateTimer) return;
-    if (import_fs3.default.existsSync(import_path3.default.join(sootsimHomeDir(), "runtime-update-disabled"))) return;
+    if (import_fs2.default.existsSync(import_path2.default.join(sootsimHomeDir(), "runtime-update-disabled"))) return;
     if (process.env.SOOTSIM_HOME && isSootsimDevCheckout() && !readActiveRuntime()) {
       return;
     }
@@ -4791,34 +4711,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");
@@ -4829,8 +4749,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");
@@ -4850,7 +4770,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,
@@ -4861,7 +4781,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();
@@ -4875,7 +4795,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 {