sootsim 0.1.36 → 0.1.37

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

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.36 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.37 | (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,700 +36,565 @@ __export(bridge_host_exports, {
 });
 module.exports = __toCommonJS(bridge_host_exports);
 var import_child_process4 = require("child_process");
-var import_fs4 = __toESM(require("fs"), 1);
-var import_http2 = require("http");
-var import_path4 = __toESM(require("path"), 1);
+var import_fs3 = __toESM(require("fs"), 1);
+var import_http3 = require("http");
+var import_path3 = __toESM(require("path"), 1);
 var import_ws = require("ws");
 
-// src/bridge-constants.ts
-var DEFAULT_SOOTSIM_BRIDGE_PORT = 7668;
+// scripts/dev-server-scanner.ts
+var import_child_process = require("child_process");
+var import_http = __toESM(require("http"), 1);
+var import_net = __toESM(require("net"), 1);
+var import_util = require("util");
 
-// src/home-paths.ts
-var import_fs = __toESM(require("fs"), 1);
-var import_os = require("os");
-var import_path = __toESM(require("path"), 1);
-var SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
-var ACTIVE_RUNTIME_FILE = "active";
-var DAEMON_LOCKFILE = "daemon.json";
-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_path.default.resolve(override);
-  return import_path.default.join((0, import_os.homedir)(), ".sootsim");
-}
-function runtimesDir() {
-  return import_path.default.join(sootsimHomeDir(), "runtimes");
-}
-function runtimeDir(version) {
-  return import_path.default.join(runtimesDir(), version);
-}
-function activeRuntimeFile() {
-  return import_path.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
-}
-function cacheDir() {
-  return import_path.default.join(sootsimHomeDir(), "cache");
-}
-function daemonLockfilePath() {
-  return import_path.default.join(sootsimHomeDir(), DAEMON_LOCKFILE);
-}
-function configFilePath() {
-  return import_path.default.join(sootsimHomeDir(), CONFIG_FILE);
+// src/config.ts
+var SOOTSIM_CONFIG_QUERY_PARAM = "sootsimConfig";
+function hasOwnKeys(value) {
+  return !!value && Object.keys(value).length > 0;
 }
-function ensureSootsimHome() {
-  import_fs.default.mkdirSync(sootsimHomeDir(), { recursive: true });
-  import_fs.default.mkdirSync(runtimesDir(), { recursive: true });
-  import_fs.default.mkdirSync(cacheDir(), { recursive: true });
+function hasSootSimConfig(config) {
+  if (!config) return false;
+  return hasOwnKeys(config.modules) || hasOwnKeys(config.turboModules) || hasOwnKeys(config.nativeModules) || hasOwnKeys(config.env) || hasOwnKeys(config.settings) || hasOwnKeys(config.initialState);
 }
-function readActiveRuntime() {
-  try {
-    const value = import_fs.default.readFileSync(activeRuntimeFile(), "utf8").trim();
-    return value.length > 0 ? value : null;
-  } catch {
-    return null;
+function applySootSimConfigToUrl(url, config) {
+  const parsed = new URL(url);
+  if (hasSootSimConfig(config)) {
+    parsed.searchParams.set(SOOTSIM_CONFIG_QUERY_PARAM, JSON.stringify(config));
+  } else {
+    parsed.searchParams.delete(SOOTSIM_CONFIG_QUERY_PARAM);
   }
+  return parsed.toString();
 }
-function writeActiveRuntime(version) {
-  import_fs.default.mkdirSync(runtimesDir(), { recursive: true });
-  import_fs.default.writeFileSync(activeRuntimeFile(), `${version}
-`, "utf8");
-}
-function listInstalledRuntimes() {
-  try {
-    return import_fs.default.readdirSync(runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
-  } catch {
-    return [];
-  }
+
+// src/native-dev-bundle-url.ts
+function isAbsoluteHttpUrl(url) {
+  return /^https?:\/\//i.test(url);
 }
-function compareSemver(a, b) {
-  const parse = (v) => {
-    const hyphen = v.indexOf("-");
-    const core = hyphen >= 0 ? v.slice(0, hyphen) : v;
-    const pre = hyphen >= 0 ? v.slice(hyphen + 1) : "";
-    const parts = core.split(".").map((n) => Number.parseInt(n, 10));
-    if (parts.some((n) => !Number.isFinite(n))) return [[Number.POSITIVE_INFINITY], v];
-    return [parts, pre];
-  };
-  const [an, ap] = parse(a);
-  const [bn, bp] = parse(b);
-  for (let i = 0; i < Math.max(an.length, bn.length); i++) {
-    const av = an[i] ?? 0;
-    const bv = bn[i] ?? 0;
-    if (av !== bv) return av - bv;
-  }
-  if (ap === bp) return 0;
-  if (!ap) return 1;
-  if (!bp) return -1;
-  return ap < bp ? -1 : 1;
+function isNativeDevBundlePath(pathname) {
+  return pathname.endsWith(".bundle");
 }
-function activeRuntimeDir() {
-  const version = readActiveRuntime();
-  if (!version) return null;
-  const dir = runtimeDir(version);
+function normalizeNativeDevBundleUrl(bundleUrl) {
   try {
-    if (import_fs.default.statSync(dir).isDirectory()) return dir;
+    const isAbsolute = isAbsoluteHttpUrl(bundleUrl);
+    const parsed = new URL(bundleUrl, "http://soot.local");
+    parsed.pathname = parsed.pathname.replace(/\.\.bundle$/, ".bundle");
+    if (!isNativeDevBundlePath(parsed.pathname)) return bundleUrl;
+    parsed.searchParams.delete("transform.bytecode");
+    if (isAbsolute) return parsed.toString();
+    return `${parsed.pathname}${parsed.search}${parsed.hash}`;
   } catch {
+    return bundleUrl;
   }
-  return null;
 }
-var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
-function readDaemonLockfile() {
-  try {
-    const fd = import_fs.default.openSync(daemonLockfilePath(), "r");
-    try {
-      const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES);
-      const bytesRead = import_fs.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") {
-        return parsed;
+
+// scripts/demo-app-registry.ts
+var import_node_fs = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var HOME = (0, import_node_os.homedir)();
+function findWorkspaceRoot(startDir) {
+  let dir = startDir;
+  while (true) {
+    if ((0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "pnpm-workspace.yaml")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "turbo.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "nx.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "lerna.json"))) {
+      return dir;
+    }
+    const packageJsonPath = (0, import_node_path.join)(dir, "package.json");
+    if ((0, import_node_fs.existsSync)(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse((0, import_node_fs.readFileSync)(packageJsonPath, "utf8"));
+        if (pkg.workspaces) return dir;
+      } catch {
       }
-      return null;
-    } finally {
-      import_fs.default.closeSync(fd);
     }
-  } catch {
-    return null;
+    const parent = (0, import_node_path.dirname)(dir);
+    if (parent === dir) return null;
+    dir = parent;
   }
 }
-function isDaemonLockfileFresh(lock, now = Date.now()) {
-  if (!lock) return false;
-  if (now - lock.heartbeatAt > DAEMON_HEARTBEAT_STALE_MS) return false;
-  try {
-    process.kill(lock.pid, 0);
-    return true;
-  } catch {
-    return false;
+function resolveWorkspaceScriptPath(workspaceRelativePath, packageRelativePath) {
+  const workspaceRoot = findWorkspaceRoot(process.cwd());
+  const candidates = [
+    workspaceRoot ? (0, import_node_path.resolve)(workspaceRoot, workspaceRelativePath) : null,
+    (0, import_node_path.resolve)(process.cwd(), workspaceRelativePath),
+    (0, import_node_path.resolve)(process.cwd(), packageRelativePath)
+  ].filter((candidate) => Boolean(candidate));
+  for (const candidate of candidates) {
+    if ((0, import_node_fs.existsSync)(candidate)) return candidate;
   }
+  return candidates[0] ?? (0, import_node_path.resolve)(process.cwd(), workspaceRelativePath);
 }
-function writeDaemonLockfile(data) {
-  ensureSootsimHome();
-  const tmp = `${daemonLockfilePath()}.tmp`;
-  import_fs.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
-`, "utf8");
-  import_fs.default.renameSync(tmp, daemonLockfilePath());
-}
-function claimDaemonLockfile(data) {
-  ensureSootsimHome();
-  const existing = readDaemonLockfile();
-  if (existing && isDaemonLockfileFresh(existing) && existing.pid !== data.pid) {
-    return false;
+var getExpensifyProxyScript = () => resolveWorkspaceScriptPath(
+  "packages/sootsim-engine/scripts/expensify-web-proxy.ts",
+  "scripts/expensify-web-proxy.ts"
+);
+var getRainbowMetadataProxyScript = () => resolveWorkspaceScriptPath(
+  "packages/sootsim-engine/scripts/rainbow-metadata-proxy.ts",
+  "scripts/rainbow-metadata-proxy.ts"
+);
+var getMattermostRNUtilsNativeModule = () => resolveWorkspaceScriptPath(
+  "packages/compat/src/stubs/mattermost-rnutils-native.ts",
+  "../compat/src/stubs/mattermost-rnutils-native.ts"
+);
+var getMattermostKeychainNativeModule = () => resolveWorkspaceScriptPath(
+  "packages/compat/src/stubs/native-seams/react-native-keychain-manager.ts",
+  "../compat/src/stubs/native-seams/react-native-keychain-manager.ts"
+);
+var getMattermostNetworkClientNativeModule = () => resolveWorkspaceScriptPath(
+  "packages/compat/src/stubs/mattermost-network-client-native.ts",
+  "../compat/src/stubs/mattermost-network-client-native.ts"
+);
+var EXPENSIFY_NATIVE_PROXY_ENV = {
+  USE_NGROK: "true",
+  NGROK_URL: "http://localhost:9000/",
+  SECURE_NGROK_URL: "http://localhost:9000/"
+};
+var MATTERMOST_DIR = (0, import_node_path.join)(HOME, "github/mattermost-mobile");
+var UNISWAP_REPO_DIR = (0, import_node_path.join)(HOME, "github/uniswap-interface");
+var UNISWAP_APP_DIR = (0, import_node_path.join)(UNISWAP_REPO_DIR, "apps/mobile");
+var UNISWAP_ENV_LOCAL_FILE = (0, import_node_path.join)(UNISWAP_REPO_DIR, ".env.defaults.local");
+var UNISWAP_PLACEHOLDER = "stored-in-.env.local";
+var UNISWAP_DEMO_ENV_MARKER = "# sootsim demo env overrides";
+var UNISWAP_FORCE_UPGRADE_HOOK_FILE = (0, import_node_path.join)(
+  UNISWAP_REPO_DIR,
+  "packages/uniswap/src/features/forceUpgrade/hooks/useForceUpgradeStatus.ts"
+);
+var UNISWAP_FORCE_UPGRADE_NOTIFICATION_FILE = (0, import_node_path.join)(
+  UNISWAP_REPO_DIR,
+  "apps/mobile/src/notification-service/data-sources/createForceUpgradeNotificationDataSource.ts"
+);
+var UNISWAP_FORCE_UPGRADE_PATCH_MARKER = "SOOTSIM_DEMO_DISABLE_FORCE_UPGRADE";
+function parseEnvFile(filePath) {
+  if (!(0, import_node_fs.existsSync)(filePath)) return {};
+  const env = {};
+  const source = (0, import_node_fs.readFileSync)(filePath, "utf8");
+  for (const rawLine of source.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const match = line.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
+    if (!match) continue;
+    let value = match[2].trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    env[match[1]] = value;
   }
-  writeDaemonLockfile(data);
-  return true;
+  return env;
 }
-function removeDaemonLockfile() {
-  try {
-    import_fs.default.unlinkSync(daemonLockfilePath());
-  } catch {
-  }
+function isUsableUniswapEnvValue(value) {
+  if (!value) return false;
+  const trimmed = value.trim();
+  if (!trimmed) return false;
+  if (trimmed.includes(UNISWAP_PLACEHOLDER)) return false;
+  if (trimmed === "TRADING_API_KEY" || trimmed === "UNISWAP_API_KEY") return false;
+  return true;
 }
-
-// src/runtime-delivery.ts
-var import_child_process = require("child_process");
-var import_crypto = __toESM(require("crypto"), 1);
-var import_fs2 = __toESM(require("fs"), 1);
-var import_path2 = __toESM(require("path"), 1);
-var import_stream = require("stream");
-var import_promises = require("stream/promises");
-var DEFAULT_RUNTIME_CDN_ORIGIN = "https://sootbean.com";
-var RUNTIME_CDN_ORIGIN_ENV = "SOOTSIM_CDN_ORIGIN";
-var RUNTIME_CHANNEL_ENV = "SOOTSIM_RUNTIME_CHANNEL";
-function readConfig() {
-  try {
-    const parsed = JSON.parse(import_fs2.default.readFileSync(configFilePath(), "utf8"));
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {};
+function pickEnvValue(sources, keys) {
+  for (const source of sources) {
+    for (const key of keys) {
+      const value = source[key];
+      if (isUsableUniswapEnvValue(value)) return value.trim();
+    }
   }
+  return void 0;
 }
-function resolveRuntimeCdnOrigin(input) {
-  const config = readConfig();
-  const value = input || process.env[RUNTIME_CDN_ORIGIN_ENV] || config.cdnOrigin || DEFAULT_RUNTIME_CDN_ORIGIN;
-  return value.replace(/\/+$/, "");
-}
-function resolveRuntimeChannel(input) {
-  const config = readConfig();
-  return input || process.env[RUNTIME_CHANNEL_ENV] || config.runtimeChannel || "stable";
-}
-function runtimeManifestUrl(cdnOrigin) {
-  const url = new URL(`${resolveRuntimeCdnOrigin(cdnOrigin)}/runtimes/manifest.json`);
-  url.searchParams.set("t", String(Date.now()));
-  return url.toString();
-}
-function runtimeTarballUrl(version, cdnOrigin) {
-  return `${resolveRuntimeCdnOrigin(cdnOrigin)}/runtimes/sootsim-runtime-${version}.tar.gz`;
-}
-async function fetchRuntimeManifest(cdnOrigin) {
-  const url = runtimeManifestUrl(cdnOrigin);
-  const res = await fetch(url, { headers: { Accept: "application/json" } });
-  if (!res.ok) {
-    throw new Error(`manifest fetch failed: ${res.status} ${res.statusText} (${url})`);
+function resolveUniswapDemoEnv() {
+  const localEnv = parseEnvFile(UNISWAP_ENV_LOCAL_FILE);
+  const webEnv = parseEnvFile((0, import_node_path.join)(UNISWAP_REPO_DIR, "apps/web/.env"));
+  const sources = [
+    process.env,
+    localEnv,
+    webEnv
+  ];
+  const env = {};
+  const bindings = [
+    ["AMPLITUDE_PROXY_URL_OVERRIDE", ["REACT_APP_AMPLITUDE_PROXY_URL"]],
+    ["QUICKNODE_ENDPOINT_NAME", ["REACT_APP_QUICKNODE_ENDPOINT_NAME"]],
+    ["QUICKNODE_ENDPOINT_TOKEN", ["REACT_APP_QUICKNODE_ENDPOINT_TOKEN"]],
+    ["INFURA_KEY", ["REACT_APP_INFURA_KEY"]],
+    ["STATSIG_API_KEY", ["REACT_APP_STATSIG_API_KEY"]],
+    ["STATSIG_PROXY_URL_OVERRIDE", ["REACT_APP_STATSIG_PROXY_URL"]],
+    ["WALLETCONNECT_PROJECT_ID", ["REACT_APP_WALLET_CONNECT_PROJECT_ID"]],
+    ["WALLETCONNECT_PROJECT_ID_BETA", ["REACT_APP_WALLET_CONNECT_PROJECT_ID"]],
+    ["WALLETCONNECT_PROJECT_ID_DEV", ["REACT_APP_WALLET_CONNECT_PROJECT_ID"]],
+    ["TRADING_API_KEY", ["REACT_APP_TRADING_API_KEY"]],
+    ["UNISWAP_API_KEY", []]
+  ];
+  for (const [target, aliases] of bindings) {
+    const value = pickEnvValue(sources, [target, ...aliases]);
+    if (!value) continue;
+    env[target] = value;
+    for (const alias of aliases) {
+      env[alias] = value;
+    }
   }
-  return await res.json();
+  const hasPrivateGatewayKeys = isUsableUniswapEnvValue(env.TRADING_API_KEY) && isUsableUniswapEnvValue(env.UNISWAP_API_KEY);
+  if (!hasPrivateGatewayKeys) {
+    const publicGraphqlUrl = pickEnvValue(sources, ["GRAPHQL_URL_OVERRIDE", "REACT_APP_AWS_API_ENDPOINT"]) || "https://interface.gateway.uniswap.org/v1/graphql";
+    env.API_BASE_URL_OVERRIDE = "https://interface.gateway.uniswap.org";
+    env.API_BASE_URL_V2_OVERRIDE = "https://interface.gateway.uniswap.org/v2";
+    env.GRAPHQL_URL_OVERRIDE = publicGraphqlUrl;
+    env.TRADING_API_URL_OVERRIDE = "https://trading-api-labs.interface.gateway.uniswap.org";
+    env.FOR_API_URL_OVERRIDE = "https://for.interface.gateway.uniswap.org/v2/FOR.v1.FORService";
+  }
+  return env;
 }
-function resolveRuntimeVersion(manifest, opts = {}) {
-  const channel = resolveRuntimeChannel(opts.channel);
-  const version = opts.version || manifest.channels[channel]?.latest;
-  if (!version) {
-    throw new Error(
-      `no version specified and channel '${channel}' has no latest entry in the manifest`
-    );
+function ensureUniswapDemoEnvLocal() {
+  const existingSource = (0, import_node_fs.existsSync)(UNISWAP_ENV_LOCAL_FILE) ? (0, import_node_fs.readFileSync)(UNISWAP_ENV_LOCAL_FILE, "utf8") : "";
+  if (existingSource && !existingSource.includes(UNISWAP_DEMO_ENV_MARKER)) {
+    return;
   }
-  const entry = manifest.versions[version];
-  if (!entry) {
-    throw new Error(
-      `version ${version} not found in manifest; available: ${Object.keys(manifest.versions).slice(-10).join(", ") || "(none)"}`
-    );
+  const env = resolveUniswapDemoEnv();
+  const lines = [UNISWAP_DEMO_ENV_MARKER];
+  for (const [key, value] of Object.entries(env).sort(([a], [b]) => a.localeCompare(b))) {
+    lines.push(`${key}=${JSON.stringify(value)}`);
   }
-  return { version, channel, entry };
+  lines.push("");
+  (0, import_node_fs.writeFileSync)(UNISWAP_ENV_LOCAL_FILE, `${lines.join("\n")}
+`);
 }
-async function installRuntime(opts = {}) {
-  ensureSootsimHome();
-  const cdnOrigin = resolveRuntimeCdnOrigin(opts.cdnOrigin);
-  const manifest = await fetchRuntimeManifest(cdnOrigin);
-  const { version, channel, entry } = resolveRuntimeVersion(manifest, opts);
-  const destDir = runtimeDir(version);
-  const setActive = opts.setActive !== false;
-  if (!opts.force && import_fs2.default.existsSync(import_path2.default.join(destDir, "index.html"))) {
-    if (setActive) writeActiveRuntime(version);
-    return {
-      version,
-      channel,
-      cdnOrigin,
-      runtimeDir: destDir,
-      installed: false,
-      activated: setActive,
-      manifest
-    };
+function ensureUniswapForceUpgradePatched() {
+  const hookNeedle = `export function useForceUpgradeStatus(): ForceUpgradeStatus {
+`;
+  const hookPatch = `  // sootsim demo: bypass the force-upgrade gate during local engine demos.
+  return 'not-required'
+
+`;
+  const hookLegacyPatch = `  // sootsim demo: bypass the force-upgrade gate during local engine demos.
+  if (process.env.${UNISWAP_FORCE_UPGRADE_PATCH_MARKER} === 'true') {
+    return 'not-required'
   }
-  const tarUrl = entry.tarball || runtimeTarballUrl(version, cdnOrigin);
-  const tarCachePath = import_path2.default.join(cacheDir(), `sootsim-runtime-${version}.tar.gz`);
-  process.stderr.write(`sootsim: downloading runtime ${version}\u2026
-`);
-  await downloadToFile(tarUrl, tarCachePath);
-  process.stderr.write(`sootsim: extracting runtime ${version}\u2026
-`);
-  const actualSha = await sha256File(tarCachePath);
-  if (actualSha !== entry.sha256) {
-    import_fs2.default.rmSync(tarCachePath, { force: true });
+
+`;
+  const notificationNeedle = `  const getForceUpgradeStatus = (): ForceUpgradeStatus => {
+`;
+  const notificationPatch = `    // sootsim demo: bypass the force-upgrade gate during local engine demos.
+    return 'not-required'
+
+`;
+  const notificationLegacyPatch = `    // sootsim demo: bypass the force-upgrade gate during local engine demos.
+    if (process.env.${UNISWAP_FORCE_UPGRADE_PATCH_MARKER} === 'true') {
+      return 'not-required'
+    }
+
+`;
+  const patchWithMigration = (filePath, needle, patch, legacyPatch) => {
+    const source = (0, import_node_fs.readFileSync)(filePath, "utf8");
+    if (source.includes(patch)) return;
+    if (source.includes(legacyPatch)) {
+      (0, import_node_fs.writeFileSync)(filePath, source.replace(legacyPatch, patch));
+      return;
+    }
+    if (!source.includes(needle)) {
+      throw new Error(
+        `uniswap demo patch failed: expected snippet not found in ${filePath}`
+      );
+    }
+    (0, import_node_fs.writeFileSync)(filePath, source.replace(needle, `${needle}${patch}`));
+  };
+  patchWithMigration(
+    UNISWAP_FORCE_UPGRADE_HOOK_FILE,
+    hookNeedle,
+    hookPatch,
+    hookLegacyPatch
+  );
+  patchWithMigration(
+    UNISWAP_FORCE_UPGRADE_NOTIFICATION_FILE,
+    notificationNeedle,
+    notificationPatch,
+    notificationLegacyPatch
+  );
+}
+var JOPLIN_DIR = (0, import_node_path.join)(HOME, "github/joplin");
+var JOPLIN_APP_DIR = (0, import_node_path.join)(JOPLIN_DIR, "packages/app-mobile");
+var JOPLIN_WATCH_ROOTS = [
+  "packages/lib",
+  "packages/renderer",
+  "packages/turndown",
+  "packages/turndown-plugin-gfm",
+  "packages/editor",
+  "packages/tools",
+  "packages/utils",
+  "packages/fork-htmlparser2",
+  "packages/fork-uslug",
+  "packages/fork-sax",
+  "packages/htmlpack",
+  "packages/react-native-saf-x",
+  "packages/react-native-alarm-notification"
+];
+function ensureJoplinWatchmanConfigs() {
+  if (!(0, import_node_fs.existsSync)(JOPLIN_DIR)) return;
+  for (const rel of JOPLIN_WATCH_ROOTS) {
+    const dir = (0, import_node_path.join)(JOPLIN_DIR, rel);
+    if (!(0, import_node_fs.existsSync)(dir)) continue;
+    const cfg = (0, import_node_path.join)(dir, ".watchmanconfig");
+    if (!(0, import_node_fs.existsSync)(cfg)) (0, import_node_fs.writeFileSync)(cfg, "{}\n");
+  }
+}
+var JOPLIN_BUILD_SENTINELS = [
+  "packages/lib/models/Setting.js",
+  "packages/turndown/lib/turndown.cjs.js",
+  "packages/app-mobile/pluginAssets/index.js"
+];
+function ensureJoplinBuilt() {
+  if (!(0, import_node_fs.existsSync)(JOPLIN_DIR)) return;
+  const missing = JOPLIN_BUILD_SENTINELS.filter(
+    (rel) => !(0, import_node_fs.existsSync)((0, import_node_path.join)(JOPLIN_DIR, rel))
+  );
+  if (missing.length === 0) return;
+  const { execSync } = require("node:child_process");
+  execSync("yarn buildParallel", {
+    cwd: JOPLIN_DIR,
+    stdio: "inherit",
+    env: { ...process.env, NO_FLIPPER: "1", CI: "" }
+  });
+  const stillMissing = JOPLIN_BUILD_SENTINELS.filter(
+    (rel) => !(0, import_node_fs.existsSync)((0, import_node_path.join)(JOPLIN_DIR, rel))
+  );
+  if (stillMissing.length > 0) {
     throw new Error(
-      `sha256 mismatch for runtime ${version}: expected ${entry.sha256}, actual ${actualSha}`
+      `joplin demo: yarn buildParallel did not produce: ${stillMissing.join(", ")}`
     );
   }
-  const tmpDir = import_path2.default.join(import_path2.default.dirname(destDir), `.installing-${version}-${process.pid}`);
-  import_fs2.default.rmSync(tmpDir, { recursive: true, force: true });
-  import_fs2.default.mkdirSync(tmpDir, { recursive: true });
-  try {
-    await extractTarball(tarCachePath, tmpDir);
-    if (!import_fs2.default.existsSync(import_path2.default.join(tmpDir, "index.html"))) {
-      throw new Error(`extracted tarball for runtime ${version} is missing index.html`);
+}
+var RAINBOW_DIR = (0, import_node_path.join)(HOME, "github/rainbow");
+var RAINBOW_GRAPHQL_DIR = (0, import_node_path.join)(RAINBOW_DIR, "src/graphql");
+var RAINBOW_GRAPHQL_CONFIG_FILE = (0, import_node_path.join)(RAINBOW_GRAPHQL_DIR, "config.js");
+var RAINBOW_NETWORKS_FILE = (0, import_node_path.join)(RAINBOW_DIR, "src/references/networks.json");
+var RAINBOW_METADATA_BASE_URL = "https://metadata.p.rainbow.me";
+var RAINBOW_METADATA_PROXY_PORT = 9011;
+var RAINBOW_DEMO_METADATA_BASE_URL = `http://127.0.0.1:${RAINBOW_METADATA_PROXY_PORT}`;
+var RAINBOW_PUBLIC_ENS_GRAPHQL_URL = "https://api.thegraph.com/subgraphs/name/ensdomains/ens";
+var RAINBOW_DEMO_QUOTE_SIGNER = "0x0000000000000000000000000000000000000000";
+var RAINBOW_DEMO_RELAY_URL = "https://relay.rainbow.me";
+var RAINBOW_DEMO_MASTER_KEY = "sootsim-rainbow-demo-master-key-do-not-use-for-real-wallets";
+var RAINBOW_DEMO_RPC_PROXY_BASE_URL = "https://rpc.rainbow.me/v1";
+var RAINBOW_DEMO_RPC_API_KEY = "";
+var RAINBOW_DEMO_PUBLIC_RPC_URLS = {
+  "1": "https://ethereum-rpc.publicnode.com"
+};
+var RAINBOW_DEMO_SERVICE_API_KEY = "sootsim-rainbow-demo-api-key";
+var RAINBOW_DEMO_SECURE_WALLET_HASH_KEY = "0x736f6f7473696d2d7261696e626f772d64656d6f2d686173682d6b6579000000";
+var RAINBOW_GRAPHQL_SENTINELS = [
+  "src/graphql/__generated__/ens.ts",
+  "src/graphql/__generated__/metadata.ts",
+  "src/graphql/__generated__/metadataPOST.ts"
+];
+function runRainbowSetupCommand(command, cwd) {
+  const { execSync } = require("node:child_process");
+  execSync(command, {
+    cwd,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      METADATA_BASE_URL: RAINBOW_METADATA_BASE_URL,
+      RAINBOW_RELAY_QUOTE_SIGNER: process.env.RAINBOW_RELAY_QUOTE_SIGNER ?? RAINBOW_DEMO_QUOTE_SIGNER
     }
-    import_fs2.default.rmSync(destDir, { recursive: true, force: true });
-    import_fs2.default.renameSync(tmpDir, destDir);
-  } catch (err) {
-    import_fs2.default.rmSync(tmpDir, { recursive: true, force: true });
-    throw err;
+  });
+}
+function ensureRainbowGraphqlConfig() {
+  if (!(0, import_node_fs.existsSync)(RAINBOW_GRAPHQL_DIR)) return;
+  const source = (0, import_node_fs.existsSync)(RAINBOW_GRAPHQL_CONFIG_FILE) ? (0, import_node_fs.readFileSync)(RAINBOW_GRAPHQL_CONFIG_FILE, "utf8") : "";
+  if (source.includes(RAINBOW_PUBLIC_ENS_GRAPHQL_URL) && source.includes(RAINBOW_METADATA_BASE_URL)) {
+    return;
   }
-  if (setActive) writeActiveRuntime(version);
-  return {
-    version,
-    channel,
-    cdnOrigin,
-    runtimeDir: destDir,
-    installed: true,
-    activated: setActive,
-    manifest
-  };
+  (0, import_node_fs.writeFileSync)(
+    RAINBOW_GRAPHQL_CONFIG_FILE,
+    `exports.config = {
+  ens: {
+    __name: 'ens',
+    document: './queries/ens.graphql',
+    schema: {
+      method: 'POST',
+      url: '${RAINBOW_PUBLIC_ENS_GRAPHQL_URL}',
+    },
+  },
+  metadata: {
+    __name: 'metadata',
+    document: './queries/metadata.graphql',
+    schema: { method: 'GET', url: '${RAINBOW_METADATA_BASE_URL}/v1/graph' },
+  },
+  metadataPOST: {
+    __name: 'metadataPOST',
+    document: './queries/metadata.graphql',
+    schema: { method: 'POST', url: '${RAINBOW_METADATA_BASE_URL}/v1/graph' },
+  },
+  arc: {
+    __name: 'arc',
+    document: './queries/arc.graphql',
+    schema: {
+      method: 'GET',
+      url: 'https://arc-graphql.rainbow.me/graphql',
+      headers: {
+        'x-api-key': 'ARC_GRAPHQL_API_KEY',
+      },
+    },
+  },
+  arcDev: {
+    __name: 'arcDev',
+    document: './queries/arc.graphql',
+    schema: {
+      method: 'GET',
+      url: 'https://arc-graphql.rainbowdotme.workers.dev/graphql',
+      headers: {},
+    },
+  },
+};
+`
+  );
 }
-async function updateRuntimeToLatest(opts = {}) {
-  ensureSootsimHome();
-  const cdnOrigin = resolveRuntimeCdnOrigin(opts.cdnOrigin);
-  const channel = resolveRuntimeChannel(opts.channel);
-  const manifest = await fetchRuntimeManifest(cdnOrigin);
-  const latestVersion = manifest.channels[channel]?.latest;
-  if (!latestVersion) {
-    return {
-      checked: true,
-      updated: false,
-      reason: `channel '${channel}' has no latest runtime`,
-      activeVersion: readActiveRuntime()
-    };
+function resolveRainbowDemoEnv() {
+  const env = {
+    ENABLE_DEV_MODE: "1",
+    IS_TESTING: "false",
+    METADATA_BASE_URL: process.env.RAINBOW_METADATA_BASE_URL ?? RAINBOW_DEMO_METADATA_BASE_URL,
+    ADDYS_API_KEY: process.env.ADDYS_API_KEY ?? RAINBOW_DEMO_SERVICE_API_KEY,
+    ADDYS_BASE_URL: process.env.ADDYS_BASE_URL ?? RAINBOW_DEMO_METADATA_BASE_URL,
+    PLATFORM_API_KEY: process.env.PLATFORM_API_KEY ?? RAINBOW_DEMO_SERVICE_API_KEY,
+    PLATFORM_BASE_URL: process.env.PLATFORM_BASE_URL ?? RAINBOW_DEMO_METADATA_BASE_URL,
+    RAINBOW_MASTER_KEY: process.env.RAINBOW_MASTER_KEY ?? RAINBOW_DEMO_MASTER_KEY,
+    RAINBOW_RELAY_QUOTE_SIGNER: process.env.RAINBOW_RELAY_QUOTE_SIGNER ?? RAINBOW_DEMO_QUOTE_SIGNER,
+    RAINBOW_RELAY_URL: process.env.RAINBOW_RELAY_URL ?? RAINBOW_DEMO_RELAY_URL,
+    RPC_PROXY_API_KEY_PROD: RAINBOW_DEMO_RPC_API_KEY,
+    RPC_PROXY_BASE_URL_PROD: process.env.RAINBOW_RPC_PROXY_BASE_URL ?? process.env.RPC_PROXY_BASE_URL_PROD ?? RAINBOW_DEMO_RPC_PROXY_BASE_URL,
+    SECURE_WALLET_HASH_KEY: process.env.SECURE_WALLET_HASH_KEY ?? RAINBOW_DEMO_SECURE_WALLET_HASH_KEY
+  };
+  const optionalEnvVars = [
+    "ADDYS_API_KEY",
+    "ADDYS_BASE_URL",
+    "IMGIX_DOMAIN",
+    "IMGIX_TOKEN",
+    "PLATFORM_API_KEY",
+    "PLATFORM_BASE_URL",
+    "RAINBOW_TEST_WALLET",
+    "RAINBOW_RELAY_API_KEY",
+    "RAINBOW_RELAY_URL",
+    "SECURE_WALLET_HASH_KEY",
+    "TOKEN_SEARCH_URL",
+    "WC_PROJECT_ID"
+  ];
+  for (const key of optionalEnvVars) {
+    const value = process.env[key];
+    if (value) env[key] = value;
   }
-  const entry = manifest.versions[latestVersion];
-  if (!entry) {
-    return {
-      checked: true,
-      updated: false,
-      reason: `manifest is missing version ${latestVersion}`,
-      activeVersion: readActiveRuntime(),
-      latestVersion
-    };
+  if (!env.WC_PROJECT_ID && process.env.RAINBOW_WALLETCONNECT_PROJECT_ID) {
+    env.WC_PROJECT_ID = process.env.RAINBOW_WALLETCONNECT_PROJECT_ID;
   }
-  const activeVersion = readActiveRuntime();
-  const activeDir = activeVersion ? runtimeDir(activeVersion) : null;
-  const activeInstalled = activeDir ? import_fs2.default.existsSync(import_path2.default.join(activeDir, "index.html")) : false;
-  const shouldInstall = !activeVersion || !activeInstalled || compareSemver(latestVersion, activeVersion) > 0;
-  if (!shouldInstall) {
-    return {
-      checked: true,
-      updated: false,
-      reason: "active runtime is current",
-      activeVersion,
-      latestVersion
-    };
+  return env;
+}
+function ensureRainbowDemoNetworks() {
+  if (!(0, import_node_fs.existsSync)(RAINBOW_NETWORKS_FILE)) return;
+  const payload = JSON.parse((0, import_node_fs.readFileSync)(RAINBOW_NETWORKS_FILE, "utf8"));
+  if (!Array.isArray(payload.networks)) return;
+  let changed = false;
+  for (const network of payload.networks) {
+    const url = network.id ? RAINBOW_DEMO_PUBLIC_RPC_URLS[network.id] : void 0;
+    if (!url || !network.defaultRPC) continue;
+    if (network.defaultRPC.url === url) continue;
+    network.defaultRPC.url = url;
+    changed = true;
+  }
+  if (changed) {
+    (0, import_node_fs.writeFileSync)(RAINBOW_NETWORKS_FILE, `${JSON.stringify(payload)}
+`);
   }
-  const install = await installRuntime({
-    version: latestVersion,
-    channel,
-    cdnOrigin,
-    setActive: false
-  });
-  return {
-    checked: true,
-    updated: true,
-    activeVersion: latestVersion,
-    latestVersion,
-    install
-  };
 }
-async function downloadToFile(url, destPath) {
-  const res = await fetch(url);
-  if (!res.ok || !res.body) {
-    throw new Error(`download failed: ${res.status} ${res.statusText} (${url})`);
+function ensureRainbowSetup() {
+  if (!(0, import_node_fs.existsSync)(RAINBOW_DIR)) return;
+  ensureRainbowGraphqlConfig();
+  if (!(0, import_node_fs.existsSync)((0, import_node_path.join)(RAINBOW_GRAPHQL_DIR, "node_modules/.bin/graphql-codegen"))) {
+    runRainbowSetupCommand("fnm exec --using=22 yarn install", RAINBOW_GRAPHQL_DIR);
+  }
+  const missingGraphql = RAINBOW_GRAPHQL_SENTINELS.some(
+    (rel) => !(0, import_node_fs.existsSync)((0, import_node_path.join)(RAINBOW_DIR, rel))
+  );
+  if (missingGraphql) {
+    runRainbowSetupCommand("fnm exec --using=22 yarn codegen", RAINBOW_GRAPHQL_DIR);
   }
-  import_fs2.default.mkdirSync(import_path2.default.dirname(destPath), { recursive: true });
-  const tmp = `${destPath}.partial`;
-  try {
-    await (0, import_promises.pipeline)(
-      import_stream.Readable.fromWeb(res.body),
-      import_fs2.default.createWriteStream(tmp)
-    );
-    import_fs2.default.renameSync(tmp, destPath);
-  } catch (err) {
-    try {
-      import_fs2.default.unlinkSync(tmp);
-    } catch {
-    }
-    throw err;
+  if (!(0, import_node_fs.existsSync)(RAINBOW_NETWORKS_FILE)) {
+    runRainbowSetupCommand("fnm exec --using=22 yarn fetch:networks", RAINBOW_DIR);
   }
+  ensureRainbowDemoNetworks();
 }
-function sha256File(filePath) {
-  return new Promise((resolve2, reject) => {
-    const hash = import_crypto.default.createHash("sha256");
-    const stream = import_fs2.default.createReadStream(filePath);
-    stream.on("data", (chunk) => hash.update(chunk));
-    stream.on("error", reject);
-    stream.on("end", () => resolve2(hash.digest("hex")));
-  });
-}
-function extractTarball(tarPath, destDir) {
-  return new Promise((resolve2, reject) => {
-    const child = (0, import_child_process.spawn)("tar", ["-xzf", tarPath, "-C", destDir], {
-      stdio: ["ignore", "inherit", "inherit"]
-    });
-    child.on("error", reject);
-    child.on("exit", (code) => {
-      if (code === 0) resolve2();
-      else reject(new Error(`tar exited with code ${code}`));
-    });
-  });
-}
-
-// src/host/agent-host.ts
-var import_node_fs4 = __toESM(require("node:fs"), 1);
-var import_node_path4 = __toESM(require("node:path"), 1);
-
-// scripts/dev-server-scanner.ts
-var import_child_process2 = require("child_process");
-var import_http = __toESM(require("http"), 1);
-var import_net = __toESM(require("net"), 1);
-var import_util = require("util");
-
-// src/config.ts
-var SOOTSIM_CONFIG_QUERY_PARAM = "sootsimConfig";
-function hasOwnKeys(value) {
-  return !!value && Object.keys(value).length > 0;
-}
-function hasSootSimConfig(config) {
-  if (!config) return false;
-  return hasOwnKeys(config.modules) || hasOwnKeys(config.turboModules) || hasOwnKeys(config.env) || hasOwnKeys(config.settings) || hasOwnKeys(config.initialState);
-}
-function applySootSimConfigToUrl(url, config) {
-  const parsed = new URL(url);
-  if (hasSootSimConfig(config)) {
-    parsed.searchParams.set(SOOTSIM_CONFIG_QUERY_PARAM, JSON.stringify(config));
-  } else {
-    parsed.searchParams.delete(SOOTSIM_CONFIG_QUERY_PARAM);
-  }
-  return parsed.toString();
-}
-
-// src/native-dev-bundle-url.ts
-function isAbsoluteHttpUrl(url) {
-  return /^https?:\/\//i.test(url);
-}
-function isNativeDevBundlePath(pathname) {
-  return pathname.endsWith(".bundle");
-}
-function normalizeNativeDevBundleUrl(bundleUrl) {
+var ARTSY_DIR = (0, import_node_path.join)(HOME, "github/eigen");
+var ARTSY_KEYS_FILE = (0, import_node_path.join)(ARTSY_DIR, "keys.shared.json");
+var ARTSY_METAFLAGS_FILE = (0, import_node_path.join)(ARTSY_DIR, "metaflags.json");
+var ARTSY_RELAY_SENTINEL = (0, import_node_path.join)(ARTSY_DIR, "src/__generated__/.relay-complete");
+function readArtsyKeysPayload() {
+  if (!(0, import_node_fs.existsSync)(ARTSY_KEYS_FILE)) return void 0;
   try {
-    const isAbsolute = isAbsoluteHttpUrl(bundleUrl);
-    const parsed = new URL(bundleUrl, "http://soot.local");
-    parsed.pathname = parsed.pathname.replace(/\.\.bundle$/, ".bundle");
-    if (!isNativeDevBundlePath(parsed.pathname)) return bundleUrl;
-    if (!parsed.searchParams.has("dev")) parsed.searchParams.set("dev", "true");
-    if (!parsed.searchParams.has("minify")) {
-      parsed.searchParams.set("minify", "false");
-    }
-    parsed.searchParams.delete("transform.bytecode");
-    if (isAbsolute) return parsed.toString();
-    return `${parsed.pathname}${parsed.search}${parsed.hash}`;
+    const parsed = JSON.parse((0, import_node_fs.readFileSync)(ARTSY_KEYS_FILE, "utf8"));
+    if (!parsed || typeof parsed !== "object") return void 0;
+    const secure = parsed.secure && typeof parsed.secure === "object" ? parsed.secure : void 0;
+    const publicKeys = parsed.public && typeof parsed.public === "object" ? parsed.public : void 0;
+    if (!secure && !publicKeys) return void 0;
+    return { secure, public: publicKeys };
   } catch {
-    return bundleUrl;
+    return void 0;
   }
 }
-
-// scripts/demo-app-registry.ts
-var import_node_fs = require("node:fs");
-var import_node_os = require("node:os");
-var import_node_path = require("node:path");
-var HOME = (0, import_node_os.homedir)();
-function findWorkspaceRoot(startDir) {
-  let dir = startDir;
-  while (true) {
-    if ((0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "pnpm-workspace.yaml")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "turbo.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "nx.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "lerna.json"))) {
-      return dir;
-    }
-    const packageJsonPath = (0, import_node_path.join)(dir, "package.json");
-    if ((0, import_node_fs.existsSync)(packageJsonPath)) {
-      try {
-        const pkg = JSON.parse((0, import_node_fs.readFileSync)(packageJsonPath, "utf8"));
-        if (pkg.workspaces) return dir;
-      } catch {
-      }
-    }
-    const parent = (0, import_node_path.dirname)(dir);
-    if (parent === dir) return null;
-    dir = parent;
+function resolveArtsyRuntimeConfig() {
+  const email = process.env.SOOTSIM_ARTSY_EMAIL ?? process.env.MAESTRO_TEST_EMAIL;
+  const password = process.env.SOOTSIM_ARTSY_PASSWORD ?? process.env.MAESTRO_TEST_PASSWORD;
+  const keys = readArtsyKeysPayload();
+  const env = {};
+  if (email && password) {
+    env.SOOTSIM_LAUNCH_ARGUMENTS = JSON.stringify({
+      email,
+      password,
+      useMaestroInit: true
+    });
   }
-}
-function resolveWorkspaceScriptPath(workspaceRelativePath, packageRelativePath) {
-  const workspaceRoot = findWorkspaceRoot(process.cwd());
-  const candidates = [
-    workspaceRoot ? (0, import_node_path.resolve)(workspaceRoot, workspaceRelativePath) : null,
-    (0, import_node_path.resolve)(process.cwd(), workspaceRelativePath),
-    (0, import_node_path.resolve)(process.cwd(), packageRelativePath)
-  ].filter((candidate) => Boolean(candidate));
-  for (const candidate of candidates) {
-    if ((0, import_node_fs.existsSync)(candidate)) return candidate;
+  if (keys) {
+    env.SOOTSIM_REACT_NATIVE_KEYS_JSON = JSON.stringify(keys);
   }
-  return candidates[0] ?? (0, import_node_path.resolve)(process.cwd(), workspaceRelativePath);
+  if (Object.keys(env).length === 0) return void 0;
+  return {
+    env
+  };
 }
-var getExpensifyProxyScript = () => resolveWorkspaceScriptPath(
-  "packages/sootsim-engine/scripts/expensify-web-proxy.ts",
-  "scripts/expensify-web-proxy.ts"
-);
-var EXPENSIFY_NATIVE_PROXY_ENV = {
-  USE_NGROK: "true",
-  NGROK_URL: "http://localhost:9000/",
-  SECURE_NGROK_URL: "http://localhost:9000/"
-};
-var UNISWAP_REPO_DIR = (0, import_node_path.join)(HOME, "github/uniswap-interface");
-var UNISWAP_APP_DIR = (0, import_node_path.join)(UNISWAP_REPO_DIR, "apps/mobile");
-var UNISWAP_ENV_LOCAL_FILE = (0, import_node_path.join)(UNISWAP_REPO_DIR, ".env.defaults.local");
-var UNISWAP_PLACEHOLDER = "stored-in-.env.local";
-var UNISWAP_DEMO_ENV_MARKER = "# sootsim demo env overrides";
-var UNISWAP_FORCE_UPGRADE_HOOK_FILE = (0, import_node_path.join)(
-  UNISWAP_REPO_DIR,
-  "packages/uniswap/src/features/forceUpgrade/hooks/useForceUpgradeStatus.ts"
-);
-var UNISWAP_FORCE_UPGRADE_NOTIFICATION_FILE = (0, import_node_path.join)(
-  UNISWAP_REPO_DIR,
-  "apps/mobile/src/notification-service/data-sources/createForceUpgradeNotificationDataSource.ts"
-);
-var UNISWAP_FORCE_UPGRADE_PATCH_MARKER = "SOOTSIM_DEMO_DISABLE_FORCE_UPGRADE";
-function parseEnvFile(filePath) {
-  if (!(0, import_node_fs.existsSync)(filePath)) return {};
-  const env = {};
-  const source = (0, import_node_fs.readFileSync)(filePath, "utf8");
-  for (const rawLine of source.split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("#")) continue;
-    const match = line.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
-    if (!match) continue;
-    let value = match[2].trim();
-    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-      value = value.slice(1, -1);
+function ensureArtsySetup() {
+  if (!(0, import_node_fs.existsSync)(ARTSY_DIR)) return;
+  const { execSync } = require("node:child_process");
+  const yarnRelease = (0, import_node_path.join)(ARTSY_DIR, ".yarn/releases/yarn-4.10.3.cjs");
+  if ((0, import_node_fs.existsSync)(yarnRelease)) {
+    const src = (0, import_node_fs.readFileSync)(yarnRelease, "utf8");
+    const needle = '["clone","-c core.autocrlf=false",';
+    if (src.includes(needle)) {
+      (0, import_node_fs.writeFileSync)(
+        yarnRelease,
+        src.replace(needle, '["clone","-c","core.autocrlf=false",')
+      );
     }
-    env[match[1]] = value;
   }
-  return env;
-}
-function isUsableUniswapEnvValue(value) {
-  if (!value) return false;
-  const trimmed = value.trim();
-  if (!trimmed) return false;
-  if (trimmed.includes(UNISWAP_PLACEHOLDER)) return false;
-  if (trimmed === "TRADING_API_KEY" || trimmed === "UNISWAP_API_KEY") return false;
-  return true;
-}
-function pickEnvValue(sources, keys) {
-  for (const source of sources) {
-    for (const key of keys) {
-      const value = source[key];
-      if (isUsableUniswapEnvValue(value)) return value.trim();
+  if (!(0, import_node_fs.existsSync)((0, import_node_path.join)(ARTSY_DIR, "node_modules/.yarn-state.yml"))) {
+    execSync("yarn install", {
+      cwd: ARTSY_DIR,
+      stdio: "inherit",
+      env: { ...process.env, YARN_CHECKSUM_BEHAVIOR: "update" }
+    });
+  }
+  if (!(0, import_node_fs.existsSync)(ARTSY_KEYS_FILE) || !(0, import_node_fs.existsSync)(ARTSY_METAFLAGS_FILE)) {
+    try {
+      execSync("yarn setup:oss", { cwd: ARTSY_DIR, stdio: "inherit" });
+    } catch {
+      if (!(0, import_node_fs.existsSync)(ARTSY_KEYS_FILE) || !(0, import_node_fs.existsSync)(ARTSY_METAFLAGS_FILE)) {
+        throw new Error("artsy demo: setup:oss did not create keys/metaflags");
+      }
     }
   }
-  return void 0;
-}
-function resolveUniswapDemoEnv() {
-  const localEnv = parseEnvFile(UNISWAP_ENV_LOCAL_FILE);
-  const webEnv = parseEnvFile((0, import_node_path.join)(UNISWAP_REPO_DIR, "apps/web/.env"));
-  const sources = [
-    process.env,
-    localEnv,
-    webEnv
-  ];
-  const env = {};
-  const bindings = [
-    ["AMPLITUDE_PROXY_URL_OVERRIDE", ["REACT_APP_AMPLITUDE_PROXY_URL"]],
-    ["QUICKNODE_ENDPOINT_NAME", ["REACT_APP_QUICKNODE_ENDPOINT_NAME"]],
-    ["QUICKNODE_ENDPOINT_TOKEN", ["REACT_APP_QUICKNODE_ENDPOINT_TOKEN"]],
-    ["INFURA_KEY", ["REACT_APP_INFURA_KEY"]],
-    ["STATSIG_API_KEY", ["REACT_APP_STATSIG_API_KEY"]],
-    ["STATSIG_PROXY_URL_OVERRIDE", ["REACT_APP_STATSIG_PROXY_URL"]],
-    ["WALLETCONNECT_PROJECT_ID", ["REACT_APP_WALLET_CONNECT_PROJECT_ID"]],
-    ["WALLETCONNECT_PROJECT_ID_BETA", ["REACT_APP_WALLET_CONNECT_PROJECT_ID"]],
-    ["WALLETCONNECT_PROJECT_ID_DEV", ["REACT_APP_WALLET_CONNECT_PROJECT_ID"]],
-    ["TRADING_API_KEY", ["REACT_APP_TRADING_API_KEY"]],
-    ["UNISWAP_API_KEY", []]
-  ];
-  for (const [target, aliases] of bindings) {
-    const value = pickEnvValue(sources, [target, ...aliases]);
-    if (!value) continue;
-    env[target] = value;
-    for (const alias of aliases) {
-      env[alias] = value;
+  const rnlaPkgJson = (0, import_node_path.join)(
+    ARTSY_DIR,
+    "node_modules/react-native-launch-arguments/package.json"
+  );
+  if ((0, import_node_fs.existsSync)(rnlaPkgJson)) {
+    const raw = (0, import_node_fs.readFileSync)(rnlaPkgJson, "utf8");
+    if (raw.includes('"dist/index.js"')) {
+      (0, import_node_fs.writeFileSync)(rnlaPkgJson, raw.replace('"dist/index.js"', '"src/index.ts"'));
     }
   }
-  const hasPrivateGatewayKeys = isUsableUniswapEnvValue(env.TRADING_API_KEY) && isUsableUniswapEnvValue(env.UNISWAP_API_KEY);
-  if (!hasPrivateGatewayKeys) {
-    const publicGraphqlUrl = pickEnvValue(sources, ["GRAPHQL_URL_OVERRIDE", "REACT_APP_AWS_API_ENDPOINT"]) || "https://interface.gateway.uniswap.org/v1/graphql";
-    env.API_BASE_URL_OVERRIDE = "https://interface.gateway.uniswap.org";
-    env.API_BASE_URL_V2_OVERRIDE = "https://interface.gateway.uniswap.org/v2";
-    env.GRAPHQL_URL_OVERRIDE = publicGraphqlUrl;
-    env.TRADING_API_URL_OVERRIDE = "https://trading-api-labs.interface.gateway.uniswap.org";
-    env.FOR_API_URL_OVERRIDE = "https://for.interface.gateway.uniswap.org/v2/FOR.v1.FORService";
-  }
-  return env;
-}
-function ensureUniswapDemoEnvLocal() {
-  const existingSource = (0, import_node_fs.existsSync)(UNISWAP_ENV_LOCAL_FILE) ? (0, import_node_fs.readFileSync)(UNISWAP_ENV_LOCAL_FILE, "utf8") : "";
-  if (existingSource && !existingSource.includes(UNISWAP_DEMO_ENV_MARKER)) {
-    return;
-  }
-  const env = resolveUniswapDemoEnv();
-  const lines = [UNISWAP_DEMO_ENV_MARKER];
-  for (const [key, value] of Object.entries(env).sort(([a], [b]) => a.localeCompare(b))) {
-    lines.push(`${key}=${JSON.stringify(value)}`);
-  }
-  lines.push("");
-  (0, import_node_fs.writeFileSync)(UNISWAP_ENV_LOCAL_FILE, `${lines.join("\n")}
-`);
-}
-function ensureUniswapForceUpgradePatched() {
-  const hookNeedle = `export function useForceUpgradeStatus(): ForceUpgradeStatus {
-`;
-  const hookPatch = `  // sootsim demo: bypass the force-upgrade gate during local engine demos.
-  return 'not-required'
-
-`;
-  const hookLegacyPatch = `  // sootsim demo: bypass the force-upgrade gate during local engine demos.
-  if (process.env.${UNISWAP_FORCE_UPGRADE_PATCH_MARKER} === 'true') {
-    return 'not-required'
-  }
-
-`;
-  const notificationNeedle = `  const getForceUpgradeStatus = (): ForceUpgradeStatus => {
-`;
-  const notificationPatch = `    // sootsim demo: bypass the force-upgrade gate during local engine demos.
-    return 'not-required'
-
-`;
-  const notificationLegacyPatch = `    // sootsim demo: bypass the force-upgrade gate during local engine demos.
-    if (process.env.${UNISWAP_FORCE_UPGRADE_PATCH_MARKER} === 'true') {
-      return 'not-required'
-    }
-
-`;
-  const patchWithMigration = (filePath, needle, patch, legacyPatch) => {
-    const source = (0, import_node_fs.readFileSync)(filePath, "utf8");
-    if (source.includes(patch)) return;
-    if (source.includes(legacyPatch)) {
-      (0, import_node_fs.writeFileSync)(filePath, source.replace(legacyPatch, patch));
-      return;
-    }
-    if (!source.includes(needle)) {
-      throw new Error(
-        `uniswap demo patch failed: expected snippet not found in ${filePath}`
-      );
-    }
-    (0, import_node_fs.writeFileSync)(filePath, source.replace(needle, `${needle}${patch}`));
-  };
-  patchWithMigration(
-    UNISWAP_FORCE_UPGRADE_HOOK_FILE,
-    hookNeedle,
-    hookPatch,
-    hookLegacyPatch
-  );
-  patchWithMigration(
-    UNISWAP_FORCE_UPGRADE_NOTIFICATION_FILE,
-    notificationNeedle,
-    notificationPatch,
-    notificationLegacyPatch
-  );
-}
-var ARTSY_DIR = (0, import_node_path.join)(HOME, "github/eigen");
-var ARTSY_KEYS_FILE = (0, import_node_path.join)(ARTSY_DIR, "keys.shared.json");
-var ARTSY_METAFLAGS_FILE = (0, import_node_path.join)(ARTSY_DIR, "metaflags.json");
-var ARTSY_RELAY_SENTINEL = (0, import_node_path.join)(ARTSY_DIR, "src/__generated__/.relay-complete");
-function readArtsyKeysPayload() {
-  if (!(0, import_node_fs.existsSync)(ARTSY_KEYS_FILE)) return void 0;
-  try {
-    const parsed = JSON.parse((0, import_node_fs.readFileSync)(ARTSY_KEYS_FILE, "utf8"));
-    if (!parsed || typeof parsed !== "object") return void 0;
-    const secure = parsed.secure && typeof parsed.secure === "object" ? parsed.secure : void 0;
-    const publicKeys = parsed.public && typeof parsed.public === "object" ? parsed.public : void 0;
-    if (!secure && !publicKeys) return void 0;
-    return { secure, public: publicKeys };
-  } catch {
-    return void 0;
-  }
-}
-function resolveArtsyRuntimeConfig() {
-  const email = process.env.SOOTSIM_ARTSY_EMAIL ?? process.env.MAESTRO_TEST_EMAIL;
-  const password = process.env.SOOTSIM_ARTSY_PASSWORD ?? process.env.MAESTRO_TEST_PASSWORD;
-  const keys = readArtsyKeysPayload();
-  const env = {};
-  if (email && password) {
-    env.SOOTSIM_LAUNCH_ARGUMENTS = JSON.stringify({
-      email,
-      password,
-      useMaestroInit: true
-    });
-  }
-  if (keys) {
-    env.SOOTSIM_REACT_NATIVE_KEYS_JSON = JSON.stringify(keys);
-  }
-  if (Object.keys(env).length === 0) return void 0;
-  return {
-    env
-  };
-}
-function ensureArtsySetup() {
-  if (!(0, import_node_fs.existsSync)(ARTSY_DIR)) return;
-  const { execSync } = require("node:child_process");
-  const yarnRelease = (0, import_node_path.join)(ARTSY_DIR, ".yarn/releases/yarn-4.10.3.cjs");
-  if ((0, import_node_fs.existsSync)(yarnRelease)) {
-    const src = (0, import_node_fs.readFileSync)(yarnRelease, "utf8");
-    const needle = '["clone","-c core.autocrlf=false",';
-    if (src.includes(needle)) {
-      (0, import_node_fs.writeFileSync)(
-        yarnRelease,
-        src.replace(needle, '["clone","-c","core.autocrlf=false",')
-      );
-    }
-  }
-  if (!(0, import_node_fs.existsSync)((0, import_node_path.join)(ARTSY_DIR, "node_modules/.yarn-state.yml"))) {
-    execSync("yarn install", {
-      cwd: ARTSY_DIR,
-      stdio: "inherit",
-      env: { ...process.env, YARN_CHECKSUM_BEHAVIOR: "update" }
-    });
-  }
-  if (!(0, import_node_fs.existsSync)(ARTSY_KEYS_FILE) || !(0, import_node_fs.existsSync)(ARTSY_METAFLAGS_FILE)) {
-    try {
-      execSync("yarn setup:oss", { cwd: ARTSY_DIR, stdio: "inherit" });
-    } catch {
-      if (!(0, import_node_fs.existsSync)(ARTSY_KEYS_FILE) || !(0, import_node_fs.existsSync)(ARTSY_METAFLAGS_FILE)) {
-        throw new Error("artsy demo: setup:oss did not create keys/metaflags");
-      }
-    }
-  }
-  const rnlaPkgJson = (0, import_node_path.join)(
-    ARTSY_DIR,
-    "node_modules/react-native-launch-arguments/package.json"
-  );
-  if ((0, import_node_fs.existsSync)(rnlaPkgJson)) {
-    const raw = (0, import_node_fs.readFileSync)(rnlaPkgJson, "utf8");
-    if (raw.includes('"dist/index.js"')) {
-      (0, import_node_fs.writeFileSync)(rnlaPkgJson, raw.replace('"dist/index.js"', '"src/index.ts"'));
-    }
-  }
-  if (!(0, import_node_fs.existsSync)(ARTSY_RELAY_SENTINEL)) {
-    execSync("yarn relay", { cwd: ARTSY_DIR, stdio: "inherit" });
-    (0, import_node_fs.writeFileSync)(ARTSY_RELAY_SENTINEL, "");
+  if (!(0, import_node_fs.existsSync)(ARTSY_RELAY_SENTINEL)) {
+    execSync("yarn relay", { cwd: ARTSY_DIR, stdio: "inherit" });
+    (0, import_node_fs.writeFileSync)(ARTSY_RELAY_SENTINEL, "");
   }
 }
 var APPS = [
@@ -776,7 +641,24 @@ var APPS = [
     dir: (0, import_node_path.join)(HOME, "takeout"),
     preferredPort: 8086,
     framework: "one",
-    command: (p) => ({ cmd: "npx one dev", env: { ONE_PORT: String(p) } })
+    // takeout needs more than Metro for the demo to actually work: better-auth
+    // (login), zero-cache (sync), and a postgres for both. `bun lite` brings
+    // up the orez-backed stack (PG + zero + s3 in one binary) plus the One
+    // dev server. takeout's env system shifts every port (web, pg, zero,
+    // minio) uniformly by PORT_OFFSET, so we derive offset = port - 8081
+    // (the base web port) to keep all backend ports clear of the default
+    // dev stack while pinning One to the demo slot. OREZ_DATA_DIR is isolated
+    // to a per-demo path so we don't fight a soot dev orez that may already
+    // be holding pglite locks on ~/takeout/.orez (soot can attach takeout as
+    // a project and spin up its own orez against the same data dir).
+    readyTimeoutMs: 24e4,
+    command: (p) => ({
+      cmd: "bun lite",
+      env: {
+        PORT_OFFSET: String(p - 8081),
+        OREZ_DATA_DIR: `${HOME}/.cache/sootsim-demo/takeout-orez`
+      }
+    })
   },
   {
     name: "expensify",
@@ -823,361 +705,907 @@ var APPS = [
       envVars: ["SOOTSIM_ARTSY_EMAIL", "SOOTSIM_ARTSY_PASSWORD"],
       note: "auto-login reuses Artsy\u2019s built-in Maestro launch-arguments hook"
     }
+  },
+  {
+    name: "rainbow",
+    label: "Rainbow",
+    dir: RAINBOW_DIR,
+    preferredPort: 8089,
+    framework: "rock",
+    sidecars: [
+      {
+        name: "metadata-proxy",
+        port: RAINBOW_METADATA_PROXY_PORT,
+        readyPath: "/health",
+        command: () => ({
+          cmd: `bun ${JSON.stringify(getRainbowMetadataProxyScript())}`,
+          env: {
+            PORT: String(RAINBOW_METADATA_PROXY_PORT),
+            RAINBOW_PUBLIC_RPC_URLS: JSON.stringify(RAINBOW_DEMO_PUBLIC_RPC_URLS),
+            RAINBOW_UPSTREAM_METADATA_BASE_URL: RAINBOW_METADATA_BASE_URL
+          }
+        })
+      }
+    ],
+    prepare: () => {
+      ensureRainbowSetup();
+    },
+    command: (p) => ({
+      cmd: `fnm exec --using=22 yarn start --port ${p} --reset-cache`,
+      env: resolveRainbowDemoEnv()
+    }),
+    credentials: {
+      envVars: [
+        "RAINBOW_TEST_WALLET",
+        "RAINBOW_WALLETCONNECT_PROJECT_ID",
+        "WC_PROJECT_ID",
+        "IMGIX_DOMAIN",
+        "IMGIX_TOKEN"
+      ],
+      note: "launcher supplies a demo encryption key and public mainnet RPC; use only a public throwaway mnemonic for RAINBOW_TEST_WALLET"
+    }
+  },
+  {
+    name: "rocket-chat",
+    label: "Rocket.Chat",
+    dir: (0, import_node_path.join)(HOME, "github/Rocket.Chat.ReactNative"),
+    preferredPort: 8093,
+    framework: "expo",
+    command: (p) => ({
+      cmd: `npx react-native start --port ${p}`,
+      env: { RUNNING_E2E_TESTS: "true" }
+    }),
+    credentials: {
+      envVars: [
+        "ROCKET_CHAT_DEMO_SERVER",
+        "ROCKET_CHAT_DEMO_USERNAME",
+        "ROCKET_CHAT_DEMO_PASSWORD"
+      ],
+      known: { SERVER: "https://mobile.qa.rocket.chat" },
+      note: "use packages/sootsim-engine/scripts/rocket-chat-demo-auth.ts to create/login a disposable QA user and print the rocketchat://auth deep link"
+    }
+  },
+  {
+    name: "mattermost",
+    label: "Mattermost",
+    dir: MATTERMOST_DIR,
+    preferredPort: 8090,
+    framework: "expo",
+    runtimeConfig: {
+      modules: {
+        // mattermost patches react-native-keychain's JS entry in its own
+        // repo; run that package and provide only the native manager seam.
+        "react-native-keychain": false,
+        "dist/assets/config.json": {
+          inline: {
+            AuthUrlScheme: "mmauth://",
+            AuthUrlSchemeDev: "mmauthbeta://",
+            DefaultServerUrl: "http://localhost:8065",
+            DefaultServerName: "Mattermost Demo",
+            TestServerUrl: "http://localhost:8065",
+            AutoSelectServerUrl: true,
+            WebsiteURL: "https://mattermost.com",
+            ServerNoticeURL: "https://github.com/mattermost/mattermost-server/blob/master/NOTICE.txt",
+            MobileNoticeURL: "https://github.com/mattermost/mattermost-mobile/blob/master/NOTICE.txt",
+            RudderApiKey: "",
+            SentryEnabled: false,
+            SentryDsnIos: "",
+            SentryDsnAndroid: "",
+            SentryOptions: {
+              deactivateStacktraceMerging: true,
+              autoBreadcrumbs: {
+                xhr: false,
+                console: true
+              },
+              severityLevelFilter: ["fatal"]
+            },
+            ShowReview: false,
+            ShowOnboarding: false,
+            ExperimentalNormalizeMarkdownLinks: false,
+            CustomRequestHeaders: {},
+            CollectNetworkMetrics: false
+          }
+        }
+      },
+      nativeModules: {
+        RNKeychainManager: { file: getMattermostKeychainNativeModule() },
+        RNUtils: { file: getMattermostRNUtilsNativeModule() },
+        GenericClient: { file: getMattermostNetworkClientNativeModule() },
+        ApiClient: { file: getMattermostNetworkClientNativeModule() },
+        WebSocketClient: { file: getMattermostNetworkClientNativeModule() }
+      }
+    },
+    command: (p) => ({
+      cmd: `npx react-native start --host 127.0.0.1 --port ${p}`
+    }),
+    credentials: {
+      known: {
+        SERVER: "http://localhost:8065",
+        USERNAME: "demo",
+        PASSWORD: "DemoPassword1!"
+      },
+      note: "local mattermost-preview seeded through the real REST API; no signup or OTP needed"
+    }
+  },
+  {
+    name: "joplin",
+    label: "Joplin",
+    dir: JOPLIN_APP_DIR,
+    preferredPort: 8084,
+    framework: "expo",
+    // joplin is local-first: sync.target defaults to 0 ("None") and the
+    // mobile startup runs WelcomeUtils.install() on first launch, which
+    // seeds a "Welcome!" folder + welcome notes. no login or external
+    // credentials are needed for a usable demo — just boot it. tenant
+    // bedrock SQLite (via react-native-sqlite-storage stub) carries the
+    // seeded notes across reloads.
+    prepare: () => {
+      ensureJoplinWatchmanConfigs();
+      ensureJoplinBuilt();
+    },
+    command: (p) => ({
+      cmd: `npx expo start --port ${p}`,
+      env: { BROWSERSLIST_IGNORE_OLD_DATA: "true" }
+    }),
+    credentials: {
+      note: "no login required \u2014 sync.target=0 (None), seed via WelcomeUtils"
+    }
+  }
+];
+
+// scripts/dev-server-scanner.ts
+var execP = (0, import_util.promisify)(import_child_process.exec);
+var TIMEOUT_MS = 250;
+var TCP_GATE_MS = 120;
+function tcpPing(port, timeout = TCP_GATE_MS) {
+  return new Promise((resolve2) => {
+    const sock = new import_net.default.Socket();
+    let settled = false;
+    const done = (ok) => {
+      if (settled) return;
+      settled = true;
+      sock.destroy();
+      resolve2(ok);
+    };
+    sock.setTimeout(timeout);
+    sock.once("connect", () => done(true));
+    sock.once("timeout", () => done(false));
+    sock.once("error", () => done(false));
+    sock.connect(port, "localhost");
+  });
+}
+function httpGet(port, path7, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
+  return new Promise((resolve2) => {
+    const req = import_http.default.request(
+      { hostname: "localhost", port, path: path7, method, timeout, headers },
+      (res) => {
+        let body = "";
+        res.on("data", (c) => body += c.toString());
+        res.on("end", () => resolve2({ statusCode: res.statusCode || 0, body }));
+      }
+    );
+    req.on("error", () => resolve2(null));
+    req.setTimeout(timeout, () => {
+      req.destroy();
+      resolve2(null);
+    });
+    req.end();
+  });
+}
+var FALLBACK_PORTS = [
+  8081,
+  8082,
+  8083,
+  8084,
+  8085,
+  8086,
+  3e3,
+  3001,
+  19e3
+].map((port) => ({ port, pid: 0 }));
+function acceptPort(port, excluded) {
+  if (port <= 0 || port >= 2e4) return false;
+  if (excluded.has(port)) return false;
+  if (port >= 5170 && port <= 5200) return false;
+  return true;
+}
+async function discoverListeningProcesses(excludePorts = []) {
+  const excluded = new Set(excludePorts);
+  try {
+    const { stdout } = await execP(
+      `lsof -iTCP -sTCP:LISTEN -P -n 2>/dev/null | grep -E '^(node|bun)'`,
+      { encoding: "utf8", timeout: 2e3 }
+    );
+    if (stdout.trim()) {
+      const seen = /* @__PURE__ */ new Map();
+      for (const line of stdout.trim().split("\n")) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 9) continue;
+        const pid = Number(parts[1]);
+        const addr = parts[8];
+        const m = addr.match(/:(\d+)$/);
+        if (!m) continue;
+        const port = Number(m[1]);
+        if (!acceptPort(port, excluded)) continue;
+        if (!seen.has(port)) seen.set(port, pid);
+      }
+      if (seen.size > 0) {
+        return [...seen.entries()].map(([port, pid]) => ({ port, pid }));
+      }
+    }
+  } catch {
+  }
+  try {
+    const { stdout } = await execP(`ss -tlnp 2>/dev/null | grep -E '"(node|bun)"'`, {
+      encoding: "utf8",
+      timeout: 2e3
+    });
+    if (stdout.trim()) {
+      const seen = /* @__PURE__ */ new Map();
+      for (const line of stdout.trim().split("\n")) {
+        const portMatch = line.match(/:(\d+)\s/);
+        const pidMatch = line.match(/pid=(\d+)/);
+        if (!portMatch) continue;
+        const port = Number(portMatch[1]);
+        const pid = pidMatch ? Number(pidMatch[1]) : 0;
+        if (!acceptPort(port, excluded)) continue;
+        if (!seen.has(port)) seen.set(port, pid);
+      }
+      if (seen.size > 0) {
+        return [...seen.entries()].map(([port, pid]) => ({ port, pid }));
+      }
+    }
+  } catch {
+  }
+  return FALLBACK_PORTS.filter((p) => acceptPort(p.port, excluded));
+}
+var cwdByPid = /* @__PURE__ */ new Map();
+async function resolveProcessCwd(pid) {
+  if (pid <= 0) return null;
+  const cached = cwdByPid.get(pid);
+  if (cached) return cached;
+  try {
+    const { stdout } = await execP(`lsof -p ${pid} -a -d cwd -Fn 2>/dev/null`, {
+      encoding: "utf8",
+      timeout: 1500
+    });
+    for (const line of stdout.split("\n")) {
+      if (line.startsWith("n") && line.length > 1) {
+        const cwd = line.slice(1).trim();
+        if (cwd) {
+          cwdByPid.set(pid, cwd);
+          return cwd;
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function makeResult(port, framework) {
+  return {
+    port,
+    framework,
+    bundleUrl: withRuntimeConfig(
+      port,
+      `http://localhost:${port}/index.bundle?platform=ios&dev=true&hot=true&minify=false`
+    ),
+    hmrUrl: `ws://localhost:${port}/hot`,
+    lastSeen: Date.now()
+  };
+}
+function withRuntimeConfig(port, bundleUrl) {
+  const knownApp = APPS.find((app) => app.preferredPort === port);
+  const configured = knownApp?.runtimeConfig ? applySootSimConfigToUrl(bundleUrl, knownApp.runtimeConfig) : bundleUrl;
+  return normalizeNativeDevBundleUrl(configured);
+}
+function isDirectOneBundleUrl(bundleUrl) {
+  return bundleUrl.includes("/node_modules/one/metro-entry.bundle");
+}
+function applyManifest(result, manifestRes, buildIconProxyUrl) {
+  if (!manifestRes) return result;
+  try {
+    const manifest = JSON.parse(manifestRes.body);
+    const client = manifest?.extra?.expoClient || manifest?.extra || {};
+    if (client.name) result.projectName = client.name;
+    if (client.ios?.bundleIdentifier) result.bundleId = client.ios.bundleIdentifier;
+    if (result.framework === "metro" && client.sdkVersion) result.framework = "expo";
+    const launchUrl2 = manifest?.launchAsset?.url;
+    if (launchUrl2 && !result.patched && !isDirectOneBundleUrl(result.bundleUrl)) {
+      result.bundleUrl = withRuntimeConfig(result.port, launchUrl2);
+    }
+    const rawIconUrl = client.iconUrl || client.ios?.iconUrl || client.icon || client.ios?.icon;
+    if (rawIconUrl) {
+      result.iconPath = rawIconUrl;
+      if (buildIconProxyUrl) {
+        if (rawIconUrl.startsWith("http")) {
+          result.iconUrl = buildIconProxyUrl(rawIconUrl);
+        } else {
+          const cleanPath = rawIconUrl.replace(/^\.\//, "");
+          result.iconUrl = buildIconProxyUrl(
+            `http://localhost:${result.port}/assets/${cleanPath}`
+          );
+        }
+      } else {
+        result.iconUrl = rawIconUrl.startsWith("http") ? rawIconUrl : `http://localhost:${result.port}/assets/${rawIconUrl.replace(/^\.\//, "")}`;
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+var knownNonPatched = /* @__PURE__ */ new Set();
+var knownNonExpo = /* @__PURE__ */ new Set();
+var knownOne = /* @__PURE__ */ new Set();
+async function probePort(port, buildIconProxyUrl) {
+  if (!await tcpPing(port)) return null;
+  const onePath = `/node_modules/one/metro-entry.bundle?platform=ios&dev=true`;
+  const [sootsimRes, statusRes, oneRes, manifestRes, expoRes] = await Promise.all([
+    knownNonPatched.has(port) ? Promise.resolve(null) : httpGet(port, "/__soot/"),
+    httpGet(port, "/status"),
+    httpGet(port, onePath, "HEAD"),
+    knownOne.has(port) ? Promise.resolve(null) : httpGet(port, "/", "GET", TIMEOUT_MS, { "expo-platform": "ios" }),
+    knownNonExpo.has(port) ? Promise.resolve(null) : httpGet(port, "/_expo/status")
+  ]);
+  if (expoRes && expoRes.statusCode === 200) {
+    knownNonExpo.delete(port);
+  } else if (!knownNonExpo.has(port)) {
+    knownNonExpo.add(port);
+  }
+  if (oneRes && oneRes.statusCode > 0 && oneRes.statusCode < 400) {
+    knownNonPatched.add(port);
+    knownOne.add(port);
+    return applyManifest(
+      {
+        port,
+        framework: "one",
+        bundleUrl: withRuntimeConfig(
+          port,
+          `http://localhost:${port}${onePath}&minify=false`
+        ),
+        hmrUrl: `ws://localhost:${port}/hot`,
+        lastSeen: Date.now()
+      },
+      manifestRes,
+      buildIconProxyUrl
+    );
+  }
+  if (statusRes && statusRes.body.includes("packager-status:running")) {
+    knownNonPatched.add(port);
+    return applyManifest(
+      makeResult(port, expoRes && expoRes.statusCode === 200 ? "expo" : "metro"),
+      manifestRes,
+      buildIconProxyUrl
+    );
+  }
+  if (manifestRes) {
+    try {
+      const manifest = JSON.parse(manifestRes.body);
+      const client = manifest?.extra?.expoClient || {};
+      if (client.name) {
+        const launchUrl2 = manifest?.launchAsset?.url || `http://localhost:${port}/index.bundle?platform=ios&dev=true&hot=true&minify=false`;
+        knownNonPatched.add(port);
+        return applyManifest(
+          {
+            port,
+            framework: "one",
+            bundleUrl: withRuntimeConfig(port, launchUrl2),
+            hmrUrl: `ws://localhost:${port}/hot`,
+            lastSeen: Date.now()
+          },
+          manifestRes,
+          buildIconProxyUrl
+        );
+      }
+    } catch {
+    }
+  }
+  if (sootsimRes && sootsimRes.statusCode === 200 && sootsimRes.body.includes("sootsim-patched")) {
+    knownNonPatched.delete(port);
+    return applyManifest(
+      {
+        port,
+        framework: "one",
+        bundleUrl: withRuntimeConfig(port, `http://localhost:${port}/__soot/bundle.js`),
+        hmrUrl: `ws://localhost:${port}/hot`,
+        lastSeen: Date.now(),
+        patched: true
+      },
+      manifestRes,
+      buildIconProxyUrl
+    );
+  }
+  knownNonPatched.add(port);
+  return null;
+}
+function isSootSelfServer(server) {
+  const projectName = server.projectName?.trim().toLowerCase();
+  if (projectName === "soot" || projectName === "sootsim") return true;
+  const bundleId = server.bundleId?.trim().toLowerCase();
+  if (bundleId?.startsWith("dev.soot")) return true;
+  return false;
+}
+var portCache = /* @__PURE__ */ new Map();
+var NEGATIVE_CACHE_TTL_MS = 3e4;
+var WEAK_RESULT_CACHE_TTL_MS = 1500;
+function isWeakCachedResult(result) {
+  if (!result) return true;
+  if (result.framework === "metro" || result.framework === "unknown") return true;
+  return false;
+}
+function hasCurrentRuntimeConfig(result) {
+  if (!result) return true;
+  return withRuntimeConfig(result.port, result.bundleUrl) === result.bundleUrl;
+}
+function __shouldReuseScannerCacheEntry(entry, pid, now = Date.now()) {
+  if (pid === 0) return false;
+  if (entry.pid !== pid) return false;
+  if (!hasCurrentRuntimeConfig(entry.result)) return false;
+  const ageMs = now - entry.cachedAt;
+  if (entry.result === null && ageMs >= NEGATIVE_CACHE_TTL_MS) return false;
+  if (isWeakCachedResult(entry.result) && ageMs >= WEAK_RESULT_CACHE_TTL_MS) return false;
+  return true;
+}
+async function scanDevServers(opts = {}) {
+  const processes = await discoverListeningProcesses(opts.excludePorts);
+  const currentPorts = new Set(processes.map((p) => p.port));
+  for (const p of [...portCache.keys()]) {
+    if (!currentPorts.has(p)) portCache.delete(p);
+  }
+  for (const p of [...knownNonPatched]) {
+    if (!currentPorts.has(p)) knownNonPatched.delete(p);
+  }
+  for (const p of [...knownNonExpo]) {
+    if (!currentPorts.has(p)) knownNonExpo.delete(p);
+  }
+  for (const p of [...knownOne]) {
+    if (!currentPorts.has(p)) knownOne.delete(p);
+  }
+  const results = [];
+  const toProbe = [];
+  for (const { port, pid } of processes) {
+    const cached = portCache.get(port);
+    if (cached && __shouldReuseScannerCacheEntry(cached, pid)) {
+      if (cached.result) results.push(cached.result);
+      continue;
+    }
+    if (cached && cached.pid !== pid) {
+      knownNonPatched.delete(port);
+      knownNonExpo.delete(port);
+      knownOne.delete(port);
+    }
+    toProbe.push({ port, pid });
+  }
+  if (toProbe.length > 0) {
+    const probed = await Promise.all(
+      toProbe.map((p) => probePort(p.port, opts.buildIconProxyUrl))
+    );
+    probed.forEach((result, i) => {
+      const { port, pid } = toProbe[i];
+      if (pid !== 0) portCache.set(port, { pid, result, cachedAt: Date.now() });
+      if (result) results.push(result);
+    });
   }
-];
+  const pidByPort = /* @__PURE__ */ new Map();
+  for (const { port, pid } of processes) {
+    if (pid > 0) pidByPort.set(port, pid);
+  }
+  await Promise.all(
+    results.map(async (result) => {
+      const pid = pidByPort.get(result.port);
+      if (!pid) return;
+      result.pid = pid;
+      const cwd = await resolveProcessCwd(pid);
+      if (cwd) result.cwd = cwd;
+    })
+  );
+  const livePids = new Set(pidByPort.values());
+  for (const pid of [...cwdByPid.keys()]) {
+    if (!livePids.has(pid)) cwdByPid.delete(pid);
+  }
+  return results.filter((r) => !isSootSelfServer(r));
+}
 
-// scripts/dev-server-scanner.ts
-var execP = (0, import_util.promisify)(import_child_process2.exec);
-var TIMEOUT_MS = 250;
-var TCP_GATE_MS = 120;
-function tcpPing(port, timeout = TCP_GATE_MS) {
-  return new Promise((resolve2) => {
-    const sock = new import_net.default.Socket();
-    let settled = false;
-    const done = (ok) => {
-      if (settled) return;
-      settled = true;
-      sock.destroy();
-      resolve2(ok);
+// src/bridge-constants.ts
+var DEFAULT_SOOTSIM_BRIDGE_PORT = 7668;
+
+// src/home-paths.ts
+var import_node_fs2 = __toESM(require("node:fs"), 1);
+var import_node_os2 = require("node:os");
+var import_node_path2 = __toESM(require("node:path"), 1);
+var SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
+var ACTIVE_RUNTIME_FILE = "active";
+var DAEMON_LOCKFILE = "daemon.json";
+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_os2.homedir)(), ".sootsim");
+}
+function runtimesDir() {
+  return import_node_path2.default.join(sootsimHomeDir(), "runtimes");
+}
+function runtimeDir(version) {
+  return import_node_path2.default.join(runtimesDir(), version);
+}
+function activeRuntimeFile() {
+  return import_node_path2.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
+}
+function electronDir() {
+  return import_node_path2.default.join(sootsimHomeDir(), "electron");
+}
+function electronUserDataDir() {
+  return import_node_path2.default.join(electronDir(), "userData");
+}
+function profilesDir() {
+  return import_node_path2.default.join(sootsimHomeDir(), "profiles");
+}
+function cacheDir() {
+  return import_node_path2.default.join(sootsimHomeDir(), "cache");
+}
+function daemonLockfilePath() {
+  return import_node_path2.default.join(sootsimHomeDir(), DAEMON_LOCKFILE);
+}
+function configFilePath() {
+  return import_node_path2.default.join(sootsimHomeDir(), CONFIG_FILE);
+}
+function readSharedConfig() {
+  try {
+    const raw = import_node_fs2.default.readFileSync(configFilePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeSharedConfig(patch) {
+  ensureSootsimHome();
+  const current = readSharedConfig();
+  const next = { ...current, ...patch };
+  if (patch.settings && typeof patch.settings === "object") {
+    next.settings = {
+      ...current.settings && typeof current.settings === "object" ? current.settings : {},
+      ...patch.settings
     };
-    sock.setTimeout(timeout);
-    sock.once("connect", () => done(true));
-    sock.once("timeout", () => done(false));
-    sock.once("error", () => done(false));
-    sock.connect(port, "localhost");
-  });
+  }
+  const tmp = `${configFilePath()}.tmp`;
+  import_node_fs2.default.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+  import_node_fs2.default.renameSync(tmp, configFilePath());
+  return next;
 }
-function httpGet(port, path7, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
-  return new Promise((resolve2) => {
-    const req = import_http.default.request(
-      { hostname: "localhost", port, path: path7, method, timeout, headers },
-      (res) => {
-        let body = "";
-        res.on("data", (c) => body += c.toString());
-        res.on("end", () => resolve2({ statusCode: res.statusCode || 0, body }));
-      }
-    );
-    req.on("error", () => resolve2(null));
-    req.setTimeout(timeout, () => {
-      req.destroy();
-      resolve2(null);
-    });
-    req.end();
-  });
+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 });
 }
-var FALLBACK_PORTS = [
-  8081,
-  8082,
-  8083,
-  8084,
-  8085,
-  8086,
-  3e3,
-  3001,
-  19e3
-].map((port) => ({ port, pid: 0 }));
-function acceptPort(port, excluded) {
-  if (port <= 0 || port >= 2e4) return false;
-  if (excluded.has(port)) return false;
-  if (port >= 5170 && port <= 5200) return false;
-  return true;
+function readActiveRuntime() {
+  try {
+    const value = import_node_fs2.default.readFileSync(activeRuntimeFile(), "utf8").trim();
+    return value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
 }
-async function discoverListeningProcesses(excludePorts = []) {
-  const excluded = new Set(excludePorts);
+function writeActiveRuntime(version) {
+  import_node_fs2.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_node_fs2.default.writeFileSync(activeRuntimeFile(), `${version}
+`, "utf8");
+}
+function listInstalledRuntimes() {
   try {
-    const { stdout } = await execP(
-      `lsof -iTCP -sTCP:LISTEN -P -n 2>/dev/null | grep -E '^(node|bun)'`,
-      { encoding: "utf8", timeout: 2e3 }
-    );
-    if (stdout.trim()) {
-      const seen = /* @__PURE__ */ new Map();
-      for (const line of stdout.trim().split("\n")) {
-        const parts = line.trim().split(/\s+/);
-        if (parts.length < 9) continue;
-        const pid = Number(parts[1]);
-        const addr = parts[8];
-        const m = addr.match(/:(\d+)$/);
-        if (!m) continue;
-        const port = Number(m[1]);
-        if (!acceptPort(port, excluded)) continue;
-        if (!seen.has(port)) seen.set(port, pid);
-      }
-      if (seen.size > 0) {
-        return [...seen.entries()].map(([port, pid]) => ({ port, pid }));
-      }
-    }
+    return import_node_fs2.default.readdirSync(runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
   } catch {
+    return [];
+  }
+}
+function compareSemver(a, b) {
+  const parse = (v) => {
+    const hyphen = v.indexOf("-");
+    const core = hyphen >= 0 ? v.slice(0, hyphen) : v;
+    const pre = hyphen >= 0 ? v.slice(hyphen + 1) : "";
+    const parts = core.split(".").map((n) => Number.parseInt(n, 10));
+    if (parts.some((n) => !Number.isFinite(n))) return [[Number.POSITIVE_INFINITY], v];
+    return [parts, pre];
+  };
+  const [an, ap] = parse(a);
+  const [bn, bp] = parse(b);
+  for (let i = 0; i < Math.max(an.length, bn.length); i++) {
+    const av = an[i] ?? 0;
+    const bv = bn[i] ?? 0;
+    if (av !== bv) return av - bv;
   }
+  if (ap === bp) return 0;
+  if (!ap) return 1;
+  if (!bp) return -1;
+  return ap < bp ? -1 : 1;
+}
+function activeRuntimeDir() {
+  const version = readActiveRuntime();
+  if (!version) return null;
+  const dir = runtimeDir(version);
   try {
-    const { stdout } = await execP(`ss -tlnp 2>/dev/null | grep -E '"(node|bun)"'`, {
-      encoding: "utf8",
-      timeout: 2e3
-    });
-    if (stdout.trim()) {
-      const seen = /* @__PURE__ */ new Map();
-      for (const line of stdout.trim().split("\n")) {
-        const portMatch = line.match(/:(\d+)\s/);
-        const pidMatch = line.match(/pid=(\d+)/);
-        if (!portMatch) continue;
-        const port = Number(portMatch[1]);
-        const pid = pidMatch ? Number(pidMatch[1]) : 0;
-        if (!acceptPort(port, excluded)) continue;
-        if (!seen.has(port)) seen.set(port, pid);
-      }
-      if (seen.size > 0) {
-        return [...seen.entries()].map(([port, pid]) => ({ port, pid }));
-      }
-    }
+    if (import_node_fs2.default.statSync(dir).isDirectory()) return dir;
   } catch {
   }
-  return FALLBACK_PORTS.filter((p) => acceptPort(p.port, excluded));
+  return null;
 }
-var cwdByPid = /* @__PURE__ */ new Map();
-async function resolveProcessCwd(pid) {
-  if (pid <= 0) return null;
-  const cached = cwdByPid.get(pid);
-  if (cached) return cached;
+var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
+function readDaemonLockfile() {
   try {
-    const { stdout } = await execP(`lsof -p ${pid} -a -d cwd -Fn 2>/dev/null`, {
-      encoding: "utf8",
-      timeout: 1500
-    });
-    for (const line of stdout.split("\n")) {
-      if (line.startsWith("n") && line.length > 1) {
-        const cwd = line.slice(1).trim();
-        if (cwd) {
-          cwdByPid.set(pid, cwd);
-          return cwd;
-        }
+    const fd = import_node_fs2.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 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") {
+        return parsed;
       }
+      return null;
+    } finally {
+      import_node_fs2.default.closeSync(fd);
     }
   } catch {
+    return null;
+  }
+}
+function isDaemonLockfileFresh(lock, now = Date.now()) {
+  if (!lock) return false;
+  if (now - lock.heartbeatAt > DAEMON_HEARTBEAT_STALE_MS) return false;
+  try {
+    process.kill(lock.pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writeDaemonLockfile(data) {
+  ensureSootsimHome();
+  const tmp = `${daemonLockfilePath()}.tmp`;
+  import_node_fs2.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+  import_node_fs2.default.renameSync(tmp, daemonLockfilePath());
+}
+function claimDaemonLockfile(data) {
+  ensureSootsimHome();
+  const existing = readDaemonLockfile();
+  if (existing && isDaemonLockfileFresh(existing) && existing.pid !== data.pid) {
+    return false;
+  }
+  writeDaemonLockfile(data);
+  return true;
+}
+function removeDaemonLockfile() {
+  try {
+    import_node_fs2.default.unlinkSync(daemonLockfilePath());
+  } catch {
+  }
+}
+
+// src/runtime-delivery.ts
+var import_child_process2 = require("child_process");
+var import_crypto = __toESM(require("crypto"), 1);
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_stream = require("stream");
+var import_promises = require("stream/promises");
+var DEFAULT_RUNTIME_CDN_ORIGIN = "https://sootbean.com";
+var RUNTIME_CDN_ORIGIN_ENV = "SOOTSIM_CDN_ORIGIN";
+var RUNTIME_CHANNEL_ENV = "SOOTSIM_RUNTIME_CHANNEL";
+function readConfig() {
+  try {
+    const parsed = JSON.parse(import_fs.default.readFileSync(configFilePath(), "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
   }
-  return null;
 }
-function makeResult(port, framework) {
-  return {
-    port,
-    framework,
-    bundleUrl: withRuntimeConfig(
-      port,
-      `http://localhost:${port}/index.bundle?platform=ios&dev=true&hot=true&minify=false`
-    ),
-    hmrUrl: `ws://localhost:${port}/hot`,
-    lastSeen: Date.now()
-  };
+function resolveRuntimeCdnOrigin(input) {
+  const config = readConfig();
+  const value = input || process.env[RUNTIME_CDN_ORIGIN_ENV] || config.cdnOrigin || DEFAULT_RUNTIME_CDN_ORIGIN;
+  return value.replace(/\/+$/, "");
 }
-function withRuntimeConfig(port, bundleUrl) {
-  const knownApp = APPS.find((app) => app.preferredPort === port);
-  const configured = knownApp?.runtimeConfig ? applySootSimConfigToUrl(bundleUrl, knownApp.runtimeConfig) : bundleUrl;
-  return normalizeNativeDevBundleUrl(configured);
+function resolveRuntimeChannel(input) {
+  const config = readConfig();
+  return input || process.env[RUNTIME_CHANNEL_ENV] || config.runtimeChannel || "stable";
 }
-function isDirectOneBundleUrl(bundleUrl) {
-  return bundleUrl.includes("/node_modules/one/metro-entry.bundle");
+function runtimeManifestUrl(cdnOrigin) {
+  const url = new URL(`${resolveRuntimeCdnOrigin(cdnOrigin)}/runtimes/manifest.json`);
+  url.searchParams.set("t", String(Date.now()));
+  return url.toString();
 }
-function applyManifest(result, manifestRes, buildIconProxyUrl) {
-  if (!manifestRes) return result;
-  try {
-    const manifest = JSON.parse(manifestRes.body);
-    const client = manifest?.extra?.expoClient || manifest?.extra || {};
-    if (client.name) result.projectName = client.name;
-    if (client.ios?.bundleIdentifier) result.bundleId = client.ios.bundleIdentifier;
-    if (result.framework === "metro" && client.sdkVersion) result.framework = "expo";
-    const launchUrl2 = manifest?.launchAsset?.url;
-    if (launchUrl2 && !result.patched && !isDirectOneBundleUrl(result.bundleUrl)) {
-      result.bundleUrl = withRuntimeConfig(result.port, launchUrl2);
-    }
-    const rawIconUrl = client.iconUrl || client.ios?.iconUrl || client.icon || client.ios?.icon;
-    if (rawIconUrl) {
-      result.iconPath = rawIconUrl;
-      if (buildIconProxyUrl) {
-        if (rawIconUrl.startsWith("http")) {
-          result.iconUrl = buildIconProxyUrl(rawIconUrl);
-        } else {
-          const cleanPath = rawIconUrl.replace(/^\.\//, "");
-          result.iconUrl = buildIconProxyUrl(
-            `http://localhost:${result.port}/assets/${cleanPath}`
-          );
-        }
-      } else {
-        result.iconUrl = rawIconUrl.startsWith("http") ? rawIconUrl : `http://localhost:${result.port}/assets/${rawIconUrl.replace(/^\.\//, "")}`;
-      }
-    }
-  } catch {
-  }
-  return result;
+function runtimeTarballUrl(version, cdnOrigin) {
+  return `${resolveRuntimeCdnOrigin(cdnOrigin)}/runtimes/sootsim-runtime-${version}.tar.gz`;
 }
-var knownNonPatched = /* @__PURE__ */ new Set();
-var knownNonExpo = /* @__PURE__ */ new Set();
-async function probePort(port, buildIconProxyUrl) {
-  if (!await tcpPing(port)) return null;
-  const onePath = `/node_modules/one/metro-entry.bundle?platform=ios&dev=true`;
-  const [sootsimRes, statusRes, oneRes, manifestRes, expoRes] = await Promise.all([
-    knownNonPatched.has(port) ? Promise.resolve(null) : httpGet(port, "/__soot/"),
-    httpGet(port, "/status"),
-    httpGet(port, onePath, "HEAD"),
-    httpGet(port, "/", "GET", TIMEOUT_MS, { "expo-platform": "ios" }),
-    knownNonExpo.has(port) ? Promise.resolve(null) : httpGet(port, "/_expo/status")
-  ]);
-  if (expoRes && expoRes.statusCode === 200) {
-    knownNonExpo.delete(port);
-  } else if (!knownNonExpo.has(port)) {
-    knownNonExpo.add(port);
+async function fetchRuntimeManifest(cdnOrigin) {
+  const url = runtimeManifestUrl(cdnOrigin);
+  const res = await fetch(url, { headers: { Accept: "application/json" } });
+  if (!res.ok) {
+    throw new Error(`manifest fetch failed: ${res.status} ${res.statusText} (${url})`);
   }
-  if (oneRes && oneRes.statusCode > 0 && oneRes.statusCode < 400) {
-    knownNonPatched.add(port);
-    return applyManifest(
-      {
-        port,
-        framework: "one",
-        bundleUrl: withRuntimeConfig(
-          port,
-          `http://localhost:${port}${onePath}&minify=false`
-        ),
-        hmrUrl: `ws://localhost:${port}/hot`,
-        lastSeen: Date.now()
-      },
-      manifestRes,
-      buildIconProxyUrl
+  return await res.json();
+}
+function resolveRuntimeVersion(manifest, opts = {}) {
+  const channel = resolveRuntimeChannel(opts.channel);
+  const version = opts.version || manifest.channels[channel]?.latest;
+  if (!version) {
+    throw new Error(
+      `no version specified and channel '${channel}' has no latest entry in the manifest`
     );
   }
-  if (statusRes && statusRes.body.includes("packager-status:running")) {
-    knownNonPatched.add(port);
-    return applyManifest(
-      makeResult(port, expoRes && expoRes.statusCode === 200 ? "expo" : "metro"),
-      manifestRes,
-      buildIconProxyUrl
+  const entry = manifest.versions[version];
+  if (!entry) {
+    throw new Error(
+      `version ${version} not found in manifest; available: ${Object.keys(manifest.versions).slice(-10).join(", ") || "(none)"}`
     );
   }
-  if (manifestRes) {
-    try {
-      const manifest = JSON.parse(manifestRes.body);
-      const client = manifest?.extra?.expoClient || {};
-      if (client.name) {
-        const launchUrl2 = manifest?.launchAsset?.url || `http://localhost:${port}/index.bundle?platform=ios&dev=true&hot=true&minify=false`;
-        knownNonPatched.add(port);
-        return applyManifest(
-          {
-            port,
-            framework: "one",
-            bundleUrl: withRuntimeConfig(port, launchUrl2),
-            hmrUrl: `ws://localhost:${port}/hot`,
-            lastSeen: Date.now()
-          },
-          manifestRes,
-          buildIconProxyUrl
-        );
-      }
-    } catch {
-    }
+  return { version, channel, entry };
+}
+async function installRuntime(opts = {}) {
+  ensureSootsimHome();
+  const cdnOrigin = resolveRuntimeCdnOrigin(opts.cdnOrigin);
+  const manifest = await fetchRuntimeManifest(cdnOrigin);
+  const { version, channel, entry } = resolveRuntimeVersion(manifest, opts);
+  const destDir = runtimeDir(version);
+  const setActive = opts.setActive !== false;
+  if (!opts.force && import_fs.default.existsSync(import_path.default.join(destDir, "index.html"))) {
+    if (setActive) writeActiveRuntime(version);
+    return {
+      version,
+      channel,
+      cdnOrigin,
+      runtimeDir: destDir,
+      installed: false,
+      activated: setActive,
+      manifest
+    };
   }
-  if (sootsimRes && sootsimRes.statusCode === 200 && sootsimRes.body.includes("sootsim-patched")) {
-    knownNonPatched.delete(port);
-    return applyManifest(
-      {
-        port,
-        framework: "one",
-        bundleUrl: withRuntimeConfig(port, `http://localhost:${port}/__soot/bundle.js`),
-        hmrUrl: `ws://localhost:${port}/hot`,
-        lastSeen: Date.now(),
-        patched: true
-      },
-      manifestRes,
-      buildIconProxyUrl
+  const tarUrl = entry.tarball || runtimeTarballUrl(version, cdnOrigin);
+  const tarCachePath = import_path.default.join(cacheDir(), `sootsim-runtime-${version}.tar.gz`);
+  process.stderr.write(`sootsim: downloading runtime ${version}\u2026
+`);
+  await downloadToFile(tarUrl, tarCachePath);
+  process.stderr.write(`sootsim: extracting runtime ${version}\u2026
+`);
+  const actualSha = await sha256File(tarCachePath);
+  if (actualSha !== entry.sha256) {
+    import_fs.default.rmSync(tarCachePath, { force: true });
+    throw new Error(
+      `sha256 mismatch for runtime ${version}: expected ${entry.sha256}, actual ${actualSha}`
     );
   }
-  knownNonPatched.add(port);
-  return null;
-}
-function isSootSelfServer(server) {
-  const projectName = server.projectName?.trim().toLowerCase();
-  if (projectName === "soot" || projectName === "sootsim") return true;
-  const bundleId = server.bundleId?.trim().toLowerCase();
-  if (bundleId?.startsWith("dev.soot")) return true;
-  return false;
-}
-var portCache = /* @__PURE__ */ new Map();
-var NEGATIVE_CACHE_TTL_MS = 3e4;
-var WEAK_RESULT_CACHE_TTL_MS = 1500;
-function isWeakCachedResult(result) {
-  if (!result) return true;
-  if (result.framework === "metro" || result.framework === "unknown") return true;
-  return false;
-}
-function hasCurrentRuntimeConfig(result) {
-  if (!result) return true;
-  return withRuntimeConfig(result.port, result.bundleUrl) === result.bundleUrl;
-}
-function __shouldReuseScannerCacheEntry(entry, pid, now = Date.now()) {
-  if (pid === 0) return false;
-  if (entry.pid !== pid) return false;
-  if (!hasCurrentRuntimeConfig(entry.result)) return false;
-  const ageMs = now - entry.cachedAt;
-  if (entry.result === null && ageMs >= NEGATIVE_CACHE_TTL_MS) return false;
-  if (isWeakCachedResult(entry.result) && ageMs >= WEAK_RESULT_CACHE_TTL_MS) return false;
-  return true;
+  const tmpDir = import_path.default.join(import_path.default.dirname(destDir), `.installing-${version}-${process.pid}`);
+  import_fs.default.rmSync(tmpDir, { recursive: true, force: true });
+  import_fs.default.mkdirSync(tmpDir, { recursive: true });
+  try {
+    await extractTarball(tarCachePath, tmpDir);
+    if (!import_fs.default.existsSync(import_path.default.join(tmpDir, "index.html"))) {
+      throw new Error(`extracted tarball for runtime ${version} is missing index.html`);
+    }
+    import_fs.default.rmSync(destDir, { recursive: true, force: true });
+    import_fs.default.renameSync(tmpDir, destDir);
+  } catch (err) {
+    import_fs.default.rmSync(tmpDir, { recursive: true, force: true });
+    throw err;
+  }
+  if (setActive) writeActiveRuntime(version);
+  return {
+    version,
+    channel,
+    cdnOrigin,
+    runtimeDir: destDir,
+    installed: true,
+    activated: setActive,
+    manifest
+  };
 }
-async function scanDevServers(opts = {}) {
-  const processes = await discoverListeningProcesses(opts.excludePorts);
-  const currentPorts = new Set(processes.map((p) => p.port));
-  for (const p of [...portCache.keys()]) {
-    if (!currentPorts.has(p)) portCache.delete(p);
+async function updateRuntimeToLatest(opts = {}) {
+  ensureSootsimHome();
+  const cdnOrigin = resolveRuntimeCdnOrigin(opts.cdnOrigin);
+  const channel = resolveRuntimeChannel(opts.channel);
+  const manifest = await fetchRuntimeManifest(cdnOrigin);
+  const latestVersion = manifest.channels[channel]?.latest;
+  if (!latestVersion) {
+    return {
+      checked: true,
+      updated: false,
+      reason: `channel '${channel}' has no latest runtime`,
+      activeVersion: readActiveRuntime()
+    };
   }
-  for (const p of [...knownNonPatched]) {
-    if (!currentPorts.has(p)) knownNonPatched.delete(p);
+  const entry = manifest.versions[latestVersion];
+  if (!entry) {
+    return {
+      checked: true,
+      updated: false,
+      reason: `manifest is missing version ${latestVersion}`,
+      activeVersion: readActiveRuntime(),
+      latestVersion
+    };
   }
-  for (const p of [...knownNonExpo]) {
-    if (!currentPorts.has(p)) knownNonExpo.delete(p);
+  const activeVersion = readActiveRuntime();
+  const activeDir = activeVersion ? runtimeDir(activeVersion) : null;
+  const activeInstalled = activeDir ? import_fs.default.existsSync(import_path.default.join(activeDir, "index.html")) : false;
+  const shouldInstall = !activeVersion || !activeInstalled || compareSemver(latestVersion, activeVersion) > 0;
+  if (!shouldInstall) {
+    return {
+      checked: true,
+      updated: false,
+      reason: "active runtime is current",
+      activeVersion,
+      latestVersion
+    };
   }
-  const results = [];
-  const toProbe = [];
-  for (const { port, pid } of processes) {
-    const cached = portCache.get(port);
-    if (cached && __shouldReuseScannerCacheEntry(cached, pid)) {
-      if (cached.result) results.push(cached.result);
-      continue;
-    }
-    if (cached && cached.pid !== pid) {
-      knownNonPatched.delete(port);
-      knownNonExpo.delete(port);
-    }
-    toProbe.push({ port, pid });
+  const install = await installRuntime({
+    version: latestVersion,
+    channel,
+    cdnOrigin,
+    setActive: false
+  });
+  return {
+    checked: true,
+    updated: true,
+    activeVersion: latestVersion,
+    latestVersion,
+    install
+  };
+}
+async function downloadToFile(url, destPath) {
+  const res = await fetch(url);
+  if (!res.ok || !res.body) {
+    throw new Error(`download failed: ${res.status} ${res.statusText} (${url})`);
   }
-  if (toProbe.length > 0) {
-    const probed = await Promise.all(
-      toProbe.map((p) => probePort(p.port, opts.buildIconProxyUrl))
+  import_fs.default.mkdirSync(import_path.default.dirname(destPath), { recursive: true });
+  const tmp = `${destPath}.partial`;
+  try {
+    await (0, import_promises.pipeline)(
+      import_stream.Readable.fromWeb(res.body),
+      import_fs.default.createWriteStream(tmp)
     );
-    probed.forEach((result, i) => {
-      const { port, pid } = toProbe[i];
-      if (pid !== 0) portCache.set(port, { pid, result, cachedAt: Date.now() });
-      if (result) results.push(result);
-    });
-  }
-  const pidByPort = /* @__PURE__ */ new Map();
-  for (const { port, pid } of processes) {
-    if (pid > 0) pidByPort.set(port, pid);
-  }
-  await Promise.all(
-    results.map(async (result) => {
-      const pid = pidByPort.get(result.port);
-      if (!pid) return;
-      result.pid = pid;
-      const cwd = await resolveProcessCwd(pid);
-      if (cwd) result.cwd = cwd;
-    })
-  );
-  const livePids = new Set(pidByPort.values());
-  for (const pid of [...cwdByPid.keys()]) {
-    if (!livePids.has(pid)) cwdByPid.delete(pid);
+    import_fs.default.renameSync(tmp, destPath);
+  } catch (err) {
+    try {
+      import_fs.default.unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
   }
-  return results.filter((r) => !isSootSelfServer(r));
 }
+function sha256File(filePath) {
+  return new Promise((resolve2, reject) => {
+    const hash = import_crypto.default.createHash("sha256");
+    const stream = import_fs.default.createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolve2(hash.digest("hex")));
+  });
+}
+function extractTarball(tarPath, destDir) {
+  return new Promise((resolve2, reject) => {
+    const child = (0, import_child_process2.spawn)("tar", ["-xzf", tarPath, "-C", destDir], {
+      stdio: ["ignore", "inherit", "inherit"]
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) resolve2();
+      else reject(new Error(`tar exited with code ${code}`));
+    });
+  });
+}
+
+// src/host/agent-host.ts
+var import_node_fs5 = __toESM(require("node:fs"), 1);
+var import_node_path5 = __toESM(require("node:path"), 1);
 
 // src/agent-sessions.ts
 var import_node_child_process = require("node:child_process");
 var import_node_crypto2 = require("node:crypto");
-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);
 var import_node_readline = __toESM(require("node:readline"), 1);
 
 // src/agent-events.ts
@@ -1221,37 +1649,20 @@ function encodeAgentPromptEnvelope(input) {
 
 // src/attached-projects.ts
 var import_node_crypto = require("node:crypto");
-var import_node_fs2 = __toESM(require("node:fs"), 1);
-var import_node_os2 = __toESM(require("node:os"), 1);
-var import_node_path2 = __toESM(require("node:path"), 1);
+var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
 var overrideDir = null;
 function userDataDir() {
   if (overrideDir) return overrideDir;
   const fromEnv = process.env.SOOTSIM_USER_DATA_DIR;
   if (fromEnv) return fromEnv;
-  try {
-    const electron = require("electron");
-    if (electron.app?.getPath) return electron.app.getPath("userData");
-  } catch {
-  }
-  return platformDefaultUserDataDir();
-}
-function platformDefaultUserDataDir() {
-  const home = import_node_os2.default.homedir();
-  if (process.platform === "darwin") {
-    return import_node_path2.default.join(home, "Library", "Application Support", "sootsim");
-  }
-  if (process.platform === "win32") {
-    return import_node_path2.default.join(process.env.APPDATA || home, "sootsim");
-  }
-  const xdg = process.env.XDG_CONFIG_HOME || import_node_path2.default.join(home, ".config");
-  return import_node_path2.default.join(xdg, "sootsim");
+  return electronUserDataDir();
 }
 function getUserDataDir() {
   return userDataDir();
 }
 function storeFile() {
-  return import_node_path2.default.join(userDataDir(), "attached-projects.json");
+  return import_node_path3.default.join(userDataDir(), "attached-projects.json");
 }
 function cloneEmpty() {
   return {
@@ -1265,7 +1676,7 @@ function loadStore() {
   const file = storeFile();
   let raw;
   try {
-    raw = import_node_fs2.default.readFileSync(file, "utf8");
+    raw = import_node_fs3.default.readFileSync(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return cloneEmpty();
     throw err;
@@ -1282,7 +1693,7 @@ function loadStore() {
   } catch (err) {
     const quarantine = `${file}.corrupt-${Date.now()}`;
     try {
-      import_node_fs2.default.renameSync(file, quarantine);
+      import_node_fs3.default.renameSync(file, quarantine);
       console.warn(
         `[sootsim] attached-projects.json was unparseable; quarantined to ${quarantine}. original error: ${err.message}`
       );
@@ -1293,16 +1704,16 @@ function loadStore() {
 }
 function writeStore(store) {
   const file = storeFile();
-  import_node_fs2.default.mkdirSync(import_node_path2.default.dirname(file), { recursive: true });
+  import_node_fs3.default.mkdirSync(import_node_path3.default.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-  const fd = import_node_fs2.default.openSync(tmp, "w", 384);
+  const fd = import_node_fs3.default.openSync(tmp, "w", 384);
   try {
-    import_node_fs2.default.writeFileSync(fd, JSON.stringify(store, null, 2));
-    import_node_fs2.default.fsyncSync(fd);
+    import_node_fs3.default.writeFileSync(fd, JSON.stringify(store, null, 2));
+    import_node_fs3.default.fsyncSync(fd);
   } finally {
-    import_node_fs2.default.closeSync(fd);
+    import_node_fs3.default.closeSync(fd);
   }
-  import_node_fs2.default.renameSync(tmp, file);
+  import_node_fs3.default.renameSync(tmp, file);
 }
 function mutateStore(fn) {
   const store = loadStore();
@@ -1311,13 +1722,13 @@ function mutateStore(fn) {
   return store;
 }
 function projectIdForCwd(cwd) {
-  return (0, import_node_crypto.createHash)("sha256").update(import_node_path2.default.resolve(cwd)).digest("hex").slice(0, 16);
+  return (0, import_node_crypto.createHash)("sha256").update(import_node_path3.default.resolve(cwd)).digest("hex").slice(0, 16);
 }
 function newSessionId() {
   return `s_${(0, import_node_crypto.randomBytes)(10).toString("hex")}`;
 }
 function upsertProject(input) {
-  const cwd = import_node_path2.default.resolve(input.cwd);
+  const cwd = import_node_path3.default.resolve(input.cwd);
   const id = projectIdForCwd(cwd);
   let result;
   mutateStore((store) => {
@@ -1343,7 +1754,7 @@ function upsertProject(input) {
     const now = Date.now();
     const created = {
       id,
-      name: input.name ?? import_node_path2.default.basename(cwd),
+      name: input.name ?? import_node_path3.default.basename(cwd),
       cwd,
       repoRoot: input.repoRoot,
       sourceRoots: input.sourceRoots ?? [cwd],
@@ -1483,8 +1894,8 @@ async function seedFromDemoAppRegistry() {
   const apps = APPS2;
   mutateStore((store) => {
     for (const app of apps) {
-      if (!import_node_fs2.default.existsSync(app.dir)) continue;
-      const cwd = import_node_path2.default.resolve(app.dir);
+      if (!import_node_fs3.default.existsSync(app.dir)) continue;
+      const cwd = import_node_path3.default.resolve(app.dir);
       const id = projectIdForCwd(cwd);
       if (store.attachedProjects.some((p) => p.id === id)) continue;
       const now = Date.now();
@@ -1508,16 +1919,16 @@ async function seedFromDemoAppRegistry() {
 
 // src/agent-sessions.ts
 function sessionDir(sessionId) {
-  return import_node_path3.default.join(getUserDataDir(), "sessions", sessionId);
+  return import_node_path4.default.join(getUserDataDir(), "sessions", sessionId);
 }
 function promptFifoPath(sessionId) {
-  return import_node_path3.default.join(sessionDir(sessionId), "prompt.in");
+  return import_node_path4.default.join(sessionDir(sessionId), "prompt.in");
 }
 function eventsFifoPath(sessionId) {
-  return import_node_path3.default.join(sessionDir(sessionId), "events.out");
+  return import_node_path4.default.join(sessionDir(sessionId), "events.out");
 }
 function transcriptPath(sessionId) {
-  return import_node_path3.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
+  return import_node_path4.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
 }
 function pidIsAlive(pid, sessionId) {
   if (!pid) return false;
@@ -1527,7 +1938,7 @@ function pidIsAlive(pid, sessionId) {
     return false;
   }
   if (sessionId) {
-    if (!import_node_fs3.default.existsSync(sessionDir(sessionId))) return false;
+    if (!import_node_fs4.default.existsSync(sessionDir(sessionId))) return false;
   }
   return true;
 }
@@ -1539,11 +1950,11 @@ function resolveSootsimInvocation() {
     const resourcesPath = process.resourcesPath;
     if (resourcesPath) {
       const candidates = [
-        import_node_path3.default.join(resourcesPath, "bin", "sootsim"),
-        import_node_path3.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
+        import_node_path4.default.join(resourcesPath, "bin", "sootsim"),
+        import_node_path4.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
       ];
       for (const c of candidates) {
-        if (import_node_fs3.default.existsSync(c)) return { cmd: c, prefixArgs: [] };
+        if (import_node_fs4.default.existsSync(c)) return { cmd: c, prefixArgs: [] };
       }
     }
   }
@@ -1566,15 +1977,15 @@ function tryWorkspaceSootsim() {
     const sootsimDir = resolveSootsimPackageDir();
     if (!sootsimDir) return null;
     const binaryName = `sootsim-${process.platform}-${process.arch}`;
-    const distBinary = import_node_path3.default.join(sootsimDir, "dist-bin", binaryName);
-    if (import_node_fs3.default.existsSync(distBinary)) return { cmd: distBinary, prefixArgs: [] };
-    const distBin = import_node_path3.default.join(sootsimDir, "dist-cli", "bin.js");
-    if (import_node_fs3.default.existsSync(distBin)) {
+    const distBinary = import_node_path4.default.join(sootsimDir, "dist-bin", binaryName);
+    if (import_node_fs4.default.existsSync(distBinary)) return { cmd: distBinary, prefixArgs: [] };
+    const distBin = import_node_path4.default.join(sootsimDir, "dist-cli", "bin.js");
+    if (import_node_fs4.default.existsSync(distBin)) {
       try {
-        const src = import_node_path3.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
-        if (import_node_fs3.default.existsSync(src)) {
-          const srcMtime = import_node_fs3.default.statSync(src).mtimeMs;
-          const buildMtime = import_node_fs3.default.statSync(distBin).mtimeMs;
+        const src = import_node_path4.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
+        if (import_node_fs4.default.existsSync(src)) {
+          const srcMtime = import_node_fs4.default.statSync(src).mtimeMs;
+          const buildMtime = import_node_fs4.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\` (watch:cli:binary builds dist-bin/ instead).`
@@ -1593,22 +2004,22 @@ function tryWorkspaceSootsim() {
 function resolveSootsimPackageDir() {
   try {
     const resolved = require.resolve("sootsim/package.json");
-    return import_node_path3.default.dirname(resolved);
+    return import_node_path4.default.dirname(resolved);
   } catch {
   }
   const here = fileFromImportMeta();
   if (!here) return null;
-  let cur = import_node_path3.default.dirname(here);
+  let cur = import_node_path4.default.dirname(here);
   for (let i = 0; i < 8; i++) {
-    const pkg = import_node_path3.default.join(cur, "package.json");
+    const pkg = import_node_path4.default.join(cur, "package.json");
     try {
-      if (import_node_fs3.default.existsSync(pkg)) {
-        const parsed = JSON.parse(import_node_fs3.default.readFileSync(pkg, "utf8"));
+      if (import_node_fs4.default.existsSync(pkg)) {
+        const parsed = JSON.parse(import_node_fs4.default.readFileSync(pkg, "utf8"));
         if (parsed.name === "sootsim") return cur;
       }
     } catch {
     }
-    const parent = import_node_path3.default.dirname(cur);
+    const parent = import_node_path4.default.dirname(cur);
     if (parent === cur) break;
     cur = parent;
   }
@@ -1624,28 +2035,28 @@ function fileFromImportMeta() {
   }
 }
 async function withStartLock(projectId, provider, fn) {
-  const lockDir = import_node_path3.default.join(getUserDataDir(), "locks");
-  import_node_fs3.default.mkdirSync(lockDir, { recursive: true });
+  const lockDir = import_node_path4.default.join(getUserDataDir(), "locks");
+  import_node_fs4.default.mkdirSync(lockDir, { recursive: true });
   try {
-    import_node_fs3.default.chmodSync(lockDir, 448);
+    import_node_fs4.default.chmodSync(lockDir, 448);
   } catch {
   }
-  const lockPath = import_node_path3.default.join(lockDir, `start-${projectId}-${provider}.lock`);
+  const lockPath = import_node_path4.default.join(lockDir, `start-${projectId}-${provider}.lock`);
   const deadline = Date.now() + 4e3;
   let fd = null;
   while (fd === null) {
     try {
-      fd = import_node_fs3.default.openSync(
+      fd = import_node_fs4.default.openSync(
         lockPath,
-        import_node_fs3.constants.O_WRONLY | import_node_fs3.constants.O_CREAT | import_node_fs3.constants.O_EXCL,
+        import_node_fs4.constants.O_WRONLY | import_node_fs4.constants.O_CREAT | import_node_fs4.constants.O_EXCL,
         384
       );
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       try {
-        const stale = Number(import_node_fs3.default.readFileSync(lockPath, "utf8").trim());
+        const stale = Number(import_node_fs4.default.readFileSync(lockPath, "utf8").trim());
         if (stale && !isProcessAlive(stale)) {
-          import_node_fs3.default.unlinkSync(lockPath);
+          import_node_fs4.default.unlinkSync(lockPath);
           continue;
         }
       } catch {
@@ -1659,15 +2070,15 @@ async function withStartLock(projectId, provider, fn) {
     }
   }
   try {
-    import_node_fs3.default.writeFileSync(fd, String(process.pid));
+    import_node_fs4.default.writeFileSync(fd, String(process.pid));
     return await fn();
   } finally {
     try {
-      import_node_fs3.default.closeSync(fd);
+      import_node_fs4.default.closeSync(fd);
     } catch {
     }
     try {
-      import_node_fs3.default.unlinkSync(lockPath);
+      import_node_fs4.default.unlinkSync(lockPath);
     } catch {
     }
   }
@@ -1681,25 +2092,25 @@ function isProcessAlive(pid) {
   }
 }
 function mkfifoSync(p) {
-  const parent = import_node_path3.default.dirname(p);
-  import_node_fs3.default.mkdirSync(parent, { recursive: true });
+  const parent = import_node_path4.default.dirname(p);
+  import_node_fs4.default.mkdirSync(parent, { recursive: true });
   try {
-    import_node_fs3.default.chmodSync(parent, 448);
+    import_node_fs4.default.chmodSync(parent, 448);
   } catch {
   }
-  if (import_node_fs3.default.existsSync(p)) {
+  if (import_node_fs4.default.existsSync(p)) {
     try {
-      const stat = import_node_fs3.default.statSync(p);
+      const stat = import_node_fs4.default.statSync(p);
       if (stat.isFIFO()) {
         try {
-          import_node_fs3.default.chmodSync(p, 384);
+          import_node_fs4.default.chmodSync(p, 384);
         } catch {
         }
         return;
       }
-      import_node_fs3.default.unlinkSync(p);
+      import_node_fs4.default.unlinkSync(p);
     } catch {
-      import_node_fs3.default.unlinkSync(p);
+      import_node_fs4.default.unlinkSync(p);
     }
   }
   const result = (0, import_node_child_process.spawnSync)("mkfifo", ["-m", "600", p]);
@@ -1746,10 +2157,10 @@ async function startSession(opts) {
     const transcript = transcriptPath(session.id);
     mkfifoSync(promptIn);
     mkfifoSync(eventsOut);
-    const transcriptDir = import_node_path3.default.dirname(transcript);
-    import_node_fs3.default.mkdirSync(transcriptDir, { recursive: true });
+    const transcriptDir = import_node_path4.default.dirname(transcript);
+    import_node_fs4.default.mkdirSync(transcriptDir, { recursive: true });
     try {
-      import_node_fs3.default.chmodSync(transcriptDir, 448);
+      import_node_fs4.default.chmodSync(transcriptDir, 448);
     } catch {
     }
     const { cmd, prefixArgs } = resolveSootsimInvocation();
@@ -1800,7 +2211,7 @@ async function startSession(opts) {
         }
       }
       try {
-        import_node_fs3.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
+        import_node_fs4.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
       } catch {
       }
       updateSessionStatus(session.id, { status: "ended" });
@@ -1828,18 +2239,18 @@ async function sendPrompt(sessionId, prompt) {
     );
   }
   const fifo = promptFifoPath(sessionId);
-  if (!import_node_fs3.default.existsSync(fifo)) {
+  if (!import_node_fs4.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `prompt FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs3.default.openSync(fifo, import_node_fs3.constants.O_WRONLY);
+  const fd = import_node_fs4.default.openSync(fifo, import_node_fs4.constants.O_WRONLY);
   try {
     const wireText = encodeAgentPromptEnvelope(prompt);
     if (!wireText) {
       throw new AgentSessionError("EMPTY_PROMPT", "prompt text is empty");
     }
-    import_node_fs3.default.writeSync(fd, wireText + "\n");
+    import_node_fs4.default.writeSync(fd, wireText + "\n");
   } finally {
-    import_node_fs3.default.closeSync(fd);
+    import_node_fs4.default.closeSync(fd);
   }
   updateSessionStatus(sessionId, {
     lastPrompt: prompt.displayText ?? prompt.text,
@@ -1861,7 +2272,7 @@ async function endSession(sessionId) {
   const base = getUserDataDir();
   if (dir.startsWith(base)) {
     try {
-      import_node_fs3.default.rmSync(dir, { recursive: true, force: true });
+      import_node_fs4.default.rmSync(dir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -1869,11 +2280,11 @@ async function endSession(sessionId) {
 }
 function subscribeEvents(sessionId, onEvent) {
   const fifo = eventsFifoPath(sessionId);
-  if (!import_node_fs3.default.existsSync(fifo)) {
+  if (!import_node_fs4.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `events FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs3.default.openSync(fifo, import_node_fs3.constants.O_RDWR);
-  const stream = import_node_fs3.default.createReadStream("", { fd, autoClose: true });
+  const fd = import_node_fs4.default.openSync(fifo, import_node_fs4.constants.O_RDWR);
+  const stream = import_node_fs4.default.createReadStream("", { fd, autoClose: true });
   const rl = import_node_readline.default.createInterface({ input: stream, crlfDelay: Infinity });
   rl.on("line", (line) => {
     const event = parseAgentEventLine(line);
@@ -1894,7 +2305,7 @@ function subscribeEvents(sessionId, onEvent) {
   };
 }
 async function waitForFirstEvent(fifo, predicate, timeoutMs) {
-  const fd = import_node_fs3.default.openSync(fifo, import_node_fs3.constants.O_RDWR | import_node_fs3.constants.O_NONBLOCK);
+  const fd = import_node_fs4.default.openSync(fifo, import_node_fs4.constants.O_RDWR | import_node_fs4.constants.O_NONBLOCK);
   const buf = Buffer.alloc(8192);
   let leftover = "";
   const deadline = Date.now() + timeoutMs;
@@ -1902,7 +2313,7 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     while (Date.now() < deadline) {
       let n = 0;
       try {
-        n = import_node_fs3.default.readSync(fd, buf, 0, buf.length, null);
+        n = import_node_fs4.default.readSync(fd, buf, 0, buf.length, null);
       } catch (err) {
         if (err.code !== "EAGAIN") throw err;
         n = 0;
@@ -1922,7 +2333,7 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     }
     return null;
   } finally {
-    import_node_fs3.default.closeSync(fd);
+    import_node_fs4.default.closeSync(fd);
   }
 }
 
@@ -2093,7 +2504,7 @@ var AgentHost = class {
     );
     const project = upsertProject({
       cwd: match.cwd,
-      name: match.projectName ?? import_node_path4.default.basename(match.cwd),
+      name: match.projectName ?? import_node_path5.default.basename(match.cwd),
       preferredProvider: input.provider ?? existing?.preferredProvider,
       sourceRoots: existing?.sourceRoots ?? [match.cwd],
       knownBundleUrls,
@@ -2104,18 +2515,18 @@ var AgentHost = class {
   }
   getTranscript(sessionId) {
     const p = transcriptPath(sessionId);
-    if (!import_node_fs4.default.existsSync(p)) {
+    if (!import_node_fs5.default.existsSync(p)) {
       return { error: "transcript not found", code: "NO_TRANSCRIPT" };
     }
-    return import_node_fs4.default.readFileSync(p, "utf8");
+    return import_node_fs5.default.readFileSync(p, "utf8");
   }
   getPaths() {
     const dir = getUserDataDir();
     return {
       userDataDir: dir,
-      storeFile: import_node_path4.default.join(dir, "attached-projects.json"),
-      sessionsDir: import_node_path4.default.join(dir, "sessions"),
-      transcriptsDir: import_node_path4.default.join(dir, "transcripts")
+      storeFile: import_node_path5.default.join(dir, "attached-projects.json"),
+      sessionsDir: import_node_path5.default.join(dir, "sessions"),
+      transcriptsDir: import_node_path5.default.join(dir, "transcripts")
     };
   }
   // --- subscription management ---
@@ -2375,11 +2786,212 @@ function mapFrameworkToProjectFramework(fw) {
   return "unknown";
 }
 
+// src/host/fetch-proxy-handler.ts
+var import_http2 = __toESM(require("http"), 1);
+var import_https = __toESM(require("https"), 1);
+var FETCH_PROXY_USER_AGENT = "sootsim";
+var STRIP_FETCH_PROXY_HEADERS = /* @__PURE__ */ new Set([
+  "host",
+  "origin",
+  "referer",
+  "user-agent",
+  "cookie",
+  "connection",
+  "keep-alive",
+  "transfer-encoding",
+  "upgrade",
+  "content-length",
+  "sec-fetch-site",
+  "sec-fetch-mode",
+  "sec-fetch-dest",
+  "sec-ch-ua",
+  "sec-ch-ua-mobile",
+  "sec-ch-ua-platform"
+]);
+var FETCH_PROXY_CORS_HEADERS = {
+  "access-control-allow-origin": "*",
+  "access-control-allow-methods": "GET,POST,PUT,DELETE,PATCH,OPTIONS",
+  "access-control-allow-headers": "*",
+  "access-control-expose-headers": "*",
+  "access-control-max-age": "3600"
+};
+function applyFetchProxyCors(res) {
+  for (const [key, value] of Object.entries(FETCH_PROXY_CORS_HEADERS)) {
+    res.setHeader(key, value);
+  }
+}
+function formatFetchProxyError(targetUrl, err) {
+  const details = [];
+  const error = err;
+  if (error?.code) details.push(error.code);
+  if (error?.message) details.push(error.message);
+  if (error?.cause?.code) details.push(error.cause.code);
+  if (error?.cause?.message) details.push(error.cause.message);
+  const uniqueDetails = [...new Set(details.filter(Boolean))];
+  const message = uniqueDetails.join(" | ") || String(err);
+  if (targetUrl.includes("stored-in-.env.local")) {
+    return `${message} | upstream url still contains placeholder env values`;
+  }
+  return message;
+}
+function buildFetchProxyHeaders(reqHeaders) {
+  const headers = {};
+  for (const [key, value] of Object.entries(reqHeaders)) {
+    if (!value) continue;
+    if (STRIP_FETCH_PROXY_HEADERS.has(key.toLowerCase())) continue;
+    headers[key] = Array.isArray(value) ? value.join(", ") : value;
+  }
+  headers["user-agent"] = FETCH_PROXY_USER_AGENT;
+  return headers;
+}
+function isFetchProxyRequestUrl(rawUrl) {
+  return rawUrl?.startsWith("/__fetch-proxy?") || rawUrl?.startsWith("/__proxy?") || false;
+}
+function isAppApiRequestUrl(rawUrl) {
+  if (!rawUrl) return false;
+  if (rawUrl.startsWith("/__app-api?")) return true;
+  if (rawUrl.startsWith("/__app-api/")) return true;
+  return false;
+}
+async function handleFetchProxyRequest(req, res) {
+  if (req.method === "OPTIONS") {
+    applyFetchProxyCors(res);
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+  const params = new URLSearchParams((req.url || "").split("?")[1] || "");
+  const targetUrl = params.get("url");
+  if (!targetUrl) {
+    applyFetchProxyCors(res);
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("missing url param");
+    return;
+  }
+  let upstreamUrl;
+  try {
+    upstreamUrl = new URL(targetUrl);
+  } catch {
+    applyFetchProxyCors(res);
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("invalid url param");
+    return;
+  }
+  const headers = buildFetchProxyHeaders(req.headers);
+  let body;
+  if (req.method !== "GET" && req.method !== "HEAD") {
+    const chunks = [];
+    for await (const chunk of req) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    if (chunks.length > 0) body = Buffer.concat(chunks);
+  }
+  let upstream;
+  try {
+    upstream = await fetch(upstreamUrl.href, {
+      method: req.method,
+      headers,
+      body,
+      redirect: "follow"
+    });
+  } catch (err) {
+    applyFetchProxyCors(res);
+    res.writeHead(502, { "Content-Type": "text/plain" });
+    res.end(`fetch proxy error: ${formatFetchProxyError(upstreamUrl.href, err)}`);
+    return;
+  }
+  upstream.headers.forEach((value, key) => {
+    const lowerKey = key.toLowerCase();
+    if (lowerKey === "content-encoding" || lowerKey === "transfer-encoding" || lowerKey === "content-length" || lowerKey === "set-cookie" || lowerKey.startsWith("access-control-")) {
+      return;
+    }
+    res.setHeader(key, value);
+  });
+  applyFetchProxyCors(res);
+  const setCookie = upstream.headers.getSetCookie?.() ?? [];
+  if (setCookie.length > 0) {
+    res.setHeader("x-sootsim-set-cookie", setCookie.join(", "));
+  }
+  res.statusCode = upstream.status;
+  const buf = Buffer.from(await upstream.arrayBuffer());
+  res.end(buf);
+}
+function handleAppApiRequest(req, res) {
+  const reqUrl = req.url || "";
+  let targetPath = "";
+  let targetOrigin = "";
+  if (reqUrl.startsWith("/__app-api?")) {
+    const parsed = new URL(reqUrl, "http://sootsim.local");
+    targetPath = parsed.searchParams.get("path") || "";
+    targetOrigin = parsed.searchParams.get("origin")?.trim() || "";
+  } else if (reqUrl.startsWith("/__app-api/")) {
+    targetPath = reqUrl.slice("/__app-api".length);
+  } else {
+    return false;
+  }
+  if (!targetOrigin) {
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("app-api: missing origin query param");
+    return true;
+  }
+  if (req.method === "OPTIONS") {
+    res.writeHead(204, {
+      "Access-Control-Allow-Origin": req.headers.origin || "*",
+      "Access-Control-Allow-Methods": "GET,POST,PUT,PATCH,DELETE,OPTIONS",
+      "Access-Control-Allow-Headers": req.headers["access-control-request-headers"] || "*",
+      "Access-Control-Allow-Credentials": "true",
+      "Access-Control-Max-Age": "86400"
+    });
+    res.end();
+    return true;
+  }
+  let targetUrl;
+  try {
+    targetUrl = new URL(targetPath, targetOrigin);
+  } catch {
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("app-api: invalid origin or path");
+    return true;
+  }
+  const transport = targetUrl.protocol === "https:" ? import_https.default : import_http2.default;
+  const fwdHeaders = { ...req.headers };
+  delete fwdHeaders.host;
+  fwdHeaders.host = targetUrl.host;
+  const proxyReq = transport.request(
+    {
+      hostname: targetUrl.hostname,
+      port: targetUrl.port || (targetUrl.protocol === "https:" ? 443 : 80),
+      path: targetUrl.pathname + targetUrl.search,
+      method: req.method,
+      headers: fwdHeaders
+    },
+    (proxyRes) => {
+      const exposedHeaders = Object.keys(proxyRes.headers).filter((name) => {
+        const lower = name.toLowerCase();
+        return !lower.startsWith("access-control-") && lower !== "set-cookie";
+      }).join(", ");
+      res.writeHead(proxyRes.statusCode ?? 502, {
+        ...proxyRes.headers,
+        "access-control-allow-origin": req.headers.origin || "*",
+        "access-control-allow-credentials": "true",
+        "access-control-expose-headers": exposedHeaders
+      });
+      proxyRes.pipe(res);
+    }
+  );
+  proxyReq.on("error", (err) => {
+    res.statusCode = 502;
+    res.end(`app proxy error: ${err.message}`);
+  });
+  req.pipe(proxyReq);
+  return true;
+}
+
 // src/host/open-url.ts
 var import_child_process3 = require("child_process");
-var import_fs3 = require("fs");
-var import_os2 = require("os");
-var import_path3 = require("path");
+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",
@@ -2417,12 +3029,12 @@ var UNIX_CHROMIUM_COMMANDS = [
 ];
 var WINDOWS_CHROMIUM_COMMANDS = ["chrome", "msedge", "brave"];
 function expandHome(candidate) {
-  return candidate.startsWith("~/") ? (0, import_path3.join)((0, import_os2.homedir)(), candidate.slice(2)) : 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_fs3.existsSync)(expanded)) return expanded;
+    if ((0, import_fs2.existsSync)(expanded)) return expanded;
   }
   return null;
 }
@@ -2441,7 +3053,7 @@ function lookupExecutable(command, platform) {
 }
 function resolveChromiumBinary(platform = process.platform) {
   const envCandidate = process.env.CHROME_PATH || process.env.CHROMIUM_PATH;
-  if (envCandidate && (0, import_fs3.existsSync)(envCandidate)) return envCandidate;
+  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;
@@ -2558,43 +3170,75 @@ var HTTP_MIME_TYPES = {
   ".map": "application/json",
   ".txt": "text/plain; charset=utf-8"
 };
+function injectSharedConfigIntoHtml(data) {
+  let payload;
+  try {
+    const cfg = readSharedConfig();
+    payload = JSON.stringify(cfg);
+  } catch {
+    payload = "{}";
+  }
+  const tag = `<script>window.__sootsimSharedConfig=${payload};</script>`;
+  const html = data.toString("utf8");
+  if (html.includes("</head>")) return html.replace("</head>", tag + "</head>");
+  if (html.includes("</body>")) return html.replace("</body>", tag + "</body>");
+  return tag + html;
+}
 var SootSimBridgeHost = class _SootSimBridgeHost {
   port;
   openUrlHandler;
   httpServer = null;
   wss = null;
   nextCommandId = 1;
-  nextBrowserId = 1;
-  browsers = /* @__PURE__ */ new Map();
-  primaryBrowserId = null;
+  nextSimNumber = 161;
+  sims = /* @__PURE__ */ new Map();
+  primarySimId = null;
   pendingCommands = /* @__PURE__ */ new Map();
   cliBySentId = /* @__PURE__ */ new Map();
-  cliBrowserBySocket = /* @__PURE__ */ new Map();
+  cliSimBySocket = /* @__PURE__ */ new Map();
   cliLastCommandAt = /* @__PURE__ */ new Map();
-  cliSessionKeyBySocket = /* @__PURE__ */ new Map();
+  cliIdentityKeyBySocket = /* @__PURE__ */ new Map();
   cliLabelBySocket = /* @__PURE__ */ new Map();
-  restorableBrowsers = /* @__PURE__ */ new Map();
+  restorableSims = /* @__PURE__ */ new Map();
   nextCliFallbackId = 1;
   cliIdleTimer = null;
   agentHost;
   static CLI_IDLE_TIMEOUT_MS = 6e4;
   static CLI_LEASE_TTL_MS = 6e5;
   static USER_ACTIVE_LEASE_TTL_MS = 8e3;
-  // explicit user actions (clicking Boot, focusing the tab to take it over)
-  // hold the tab longer than passive canvas interaction so reconnecting clis
+  // explicit user actions (clicking Boot, focusing the sim to take it over)
+  // hold the sim longer than passive canvas interaction so reconnecting clis
   // can't immediately reclaim while the user gets oriented.
   static USER_BOOT_LEASE_TTL_MS = 6e4;
-  static BROWSER_RECONNECT_TTL_MS = 3e4;
+  static SIM_RECONNECT_TTL_MS = 3e4;
   preferredPort;
   portFallbackCount;
   shouldWriteLockfile;
   effectivePort = 0;
   startedAt = 0;
   heartbeatTimer = null;
+  // ws-level heartbeat: sims that hang up uncleanly (page navigated, network
+  // dropped, sim crashed) leave their server-side WebSocket sitting "open"
+  // forever. ping every WS_HEARTBEAT_INTERVAL_MS; if the previous round's
+  // ping was never answered, terminate(). that fires 'close' which runs the
+  // sim-cleanup path and stops `sootsim list` from showing 8 zombie
+  // sims that all time out on every command.
+  wsHeartbeatTimer = null;
+  wsIsAlive = /* @__PURE__ */ new WeakMap();
+  static WS_HEARTBEAT_INTERVAL_MS = 3e4;
   runtimeUpdateTimer = null;
   runtimeUpdateInFlight = null;
   activeRuntimeVersion = null;
   activeRuntimeDirPath = null;
+  // /__server-scan cache. mirrors the shell vite dev-middleware so engine
+  // ConnectRN / DemoConnectApp see the same JSON shape whether they boot
+  // from vite dev or from this daemon. without this, the SPA fallback below
+  // would serve index.html for /__server-scan and tenant-worker .json()
+  // crashes with "Unexpected token '<', "<!doctype "... is not valid JSON".
+  scanCache = null;
+  scanCacheAt = 0;
+  inflightScan = null;
+  static SCAN_FRESH_MS = 2e3;
   constructor(opts = {}) {
     this.preferredPort = opts.port || DEFAULT_SOOTSIM_BRIDGE_PORT;
     this.port = this.preferredPort;
@@ -2652,7 +3296,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
   }
   bindOnce(port, _silent) {
     return new Promise((resolve2, reject) => {
-      const server = (0, import_http2.createServer)((req, res) => this.handleHttpRequest(req, res));
+      const server = (0, import_http3.createServer)((req, res) => this.handleHttpRequest(req, res));
       let settled = false;
       const onError = (err) => {
         if (settled) return;
@@ -2687,14 +3331,18 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
     if (!this.wss) return;
     this.wss.on("connection", (ws, req) => {
       const origin = req.headers.origin;
-      const role = origin ? "browser" : "cli";
-      let browser = null;
+      const role = origin ? "sim" : "cli";
+      let sim = null;
       ws.on("error", () => {
       });
+      this.wsIsAlive.set(ws, true);
+      ws.on("pong", () => {
+        this.wsIsAlive.set(ws, true);
+      });
       this.agentHost.registerSocket(ws);
-      if (role === "browser") {
-        browser = {
-          id: `tab-${this.nextBrowserId++}`,
+      if (role === "sim") {
+        sim = {
+          id: this.allocateSimId(),
           ws,
           origin,
           connectedAt: Date.now(),
@@ -2702,15 +3350,15 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
           lastActiveAt: 0,
           recentActions: []
         };
-        this.browsers.set(browser.id, browser);
-        if (this.shouldPromoteBrowser(browser)) {
-          this.primaryBrowserId = browser.id;
+        this.sims.set(sim.id, sim);
+        if (this.shouldPromoteSim(sim)) {
+          this.primarySimId = sim.id;
         }
-        this.broadcastBrowserAssignments();
-        this.broadcastBrowserClientStates();
+        this.broadcastSimAssignments();
+        this.broadcastSimClientStates();
       } else {
         const fallbackKey = `ws-${this.nextCliFallbackId++}`;
-        this.cliSessionKeyBySocket.set(ws, fallbackKey);
+        this.cliIdentityKeyBySocket.set(ws, fallbackKey);
       }
       ws.on("message", (data) => {
         let msg;
@@ -2785,29 +3433,55 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
           }
           return;
         }
-        if (role === "browser") {
-          if (browser) {
-            browser.lastSeenAt = Date.now();
+        if (role === "sim") {
+          if (sim) {
+            sim.lastSeenAt = Date.now();
           }
-          if (msg.type === "bridge:register" && browser) {
+          if (msg.type === "bridge:register" && sim) {
             const registration = msg;
-            const restored = this.tryRestoreBrowserId(browser, registration.browserId);
-            browser.url = registration.url;
-            browser.title = registration.title;
-            browser.userAgent = registration.userAgent;
+            const restored = this.tryRestoreSimId(sim, registration.simId);
+            sim.url = registration.url;
+            sim.title = registration.title;
+            sim.userAgent = registration.userAgent;
             if (restored) {
-              this.broadcastBrowserAssignments();
-              this.broadcastBrowserClientStates();
+              this.broadcastSimAssignments();
+              this.broadcastSimClientStates();
             }
             return;
           }
-          if (msg.type === "bridge:user-focus-state" && browser) {
+          if (msg.type === "bridge:user-focus-state" && sim) {
             const focusState = msg;
-            this.updateUserFocusLease(browser, focusState.focused === true);
+            this.updateUserFocusLease(sim, focusState.focused === true);
             return;
           }
-          if (msg.type === "bridge:user-interact" && browser) {
-            this.updateUserActivity(browser);
+          if (msg.type === "bridge:user-interact" && sim) {
+            this.updateUserActivity(sim);
+            return;
+          }
+          if (msg.type === "bridge:write-shared-config") {
+            const patch = msg.patch && typeof msg.patch === "object" ? msg.patch : null;
+            if (!patch) return;
+            let next;
+            try {
+              next = writeSharedConfig(patch);
+            } catch (err) {
+              process.stderr.write(
+                `sootsim: bridge:write-shared-config failed: ${err instanceof Error ? err.message : String(err)}
+`
+              );
+              return;
+            }
+            const payload = JSON.stringify({
+              type: "bridge:shared-config-changed",
+              config: next
+            });
+            for (const peer of this.sims.values()) {
+              if (peer.ws.readyState !== import_ws.WebSocket.OPEN) continue;
+              try {
+                peer.ws.send(payload);
+              } catch {
+              }
+            }
             return;
           }
           if (msg.type === "bridge:open-path") {
@@ -2819,33 +3493,33 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
             }
             return;
           }
-          if (msg.type === "bridge:boot-clients" && browser) {
+          if (msg.type === "bridge:boot-clients" && sim) {
             const booted = [];
-            for (const [cliWs, attachedBrowserId] of this.cliBrowserBySocket) {
-              if (attachedBrowserId === browser.id) {
+            for (const [cliWs, attachedSimId] of this.cliSimBySocket) {
+              if (attachedSimId === sim.id) {
                 booted.push(cliWs);
               }
             }
             for (const cliWs of booted) {
-              this.cliBrowserBySocket.delete(cliWs);
+              this.cliSimBySocket.delete(cliWs);
               try {
-                cliWs.close(1e3, "booted by browser");
+                cliWs.close(1e3, "booted by sim");
               } catch {
               }
             }
-            const hadLease = !!browser.cliLease;
-            browser.cliLease = {
+            const hadLease = !!sim.cliLease;
+            sim.cliLease = {
               kind: "user-active",
-              cliSessionKey: "__user-active__",
+              cliIdentityKey: "__user-active__",
               cliLabel: "active user",
               expiresAt: Date.now() + _SootSimBridgeHost.USER_BOOT_LEASE_TTL_MS
             };
             process.stderr.write(
-              `sootsim booted ${booted.length} cli client(s)${hadLease ? " (overrode prior lease)" : ""}; held tab for user [${browser.id}]
+              `sootsim booted ${booted.length} cli client(s)${hadLease ? " (overrode prior lease)" : ""}; held sim for user [${sim.id}]
 `
             );
-            this.recordBrowserAction(browser.id, "browser booted cli clients");
-            this.broadcastBrowserClientStates();
+            this.recordSimAction(sim.id, "sim booted cli clients");
+            this.broadcastSimClientStates();
             return;
           }
           const internalPending = this.pendingCommands.get(msg.id);
@@ -2859,10 +3533,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
           if (entry) {
             this.cliBySentId.delete(msg.id);
             if (entry.ws.readyState === import_ws.WebSocket.OPEN) {
-              const otherCliCount = this.getOtherCliSessionCount(
-                entry.ws,
-                entry.browserId
-              );
+              const otherCliCount = this.getOtherCliIdentityCount(entry.ws, entry.simId);
               const response = otherCliCount > 0 ? { ...msg, id: entry.originalId, _otherCliCount: otherCliCount } : { ...msg, id: entry.originalId };
               entry.ws.send(JSON.stringify(response));
             }
@@ -2873,19 +3544,19 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
           this.cliLastCommandAt.set(ws, Date.now());
           try {
             if (msg.type === "bridge:bye") {
-              const hadBrowser = this.cliBrowserBySocket.delete(ws);
+              const hadSim = this.cliSimBySocket.delete(ws);
               this.cliLastCommandAt.delete(ws);
-              this.cliSessionKeyBySocket.delete(ws);
+              this.cliIdentityKeyBySocket.delete(ws);
               this.cliLabelBySocket.delete(ws);
               for (const [sentId2, entry] of this.cliBySentId) {
                 if (entry.ws === ws) this.cliBySentId.delete(sentId2);
               }
-              if (hadBrowser) this.broadcastBrowserClientStates();
+              if (hadSim) this.broadcastSimClientStates();
               return;
             }
             if (msg.type === "bridge:hello") {
-              const key = typeof msg.cliSessionKey === "string" && msg.cliSessionKey.trim() ? msg.cliSessionKey.trim() : this.cliSessionKeyBySocket.get(ws) || `ws-${this.nextCliFallbackId++}`;
-              this.cliSessionKeyBySocket.set(ws, key);
+              const key = typeof msg.cliIdentityKey === "string" && msg.cliIdentityKey.trim() ? msg.cliIdentityKey.trim() : this.cliIdentityKeyBySocket.get(ws) || `ws-${this.nextCliFallbackId++}`;
+              this.cliIdentityKeyBySocket.set(ws, key);
               if (typeof msg.cliLabel === "string" && msg.cliLabel.trim()) {
                 this.cliLabelBySocket.set(ws, msg.cliLabel.trim());
               }
@@ -2894,7 +3565,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
                   JSON.stringify({
                     id: msg.id,
                     result: {
-                      cliSessionKey: key,
+                      cliIdentityKey: key,
                       leaseTtlMs: _SootSimBridgeHost.CLI_LEASE_TTL_MS,
                       leasing: true
                     }
@@ -2903,12 +3574,12 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
               }
               return;
             }
-            if (msg.type === "bridge:list-browsers") {
+            if (msg.type === "bridge:list-sims") {
               if (ws.readyState === import_ws.WebSocket.OPEN) {
                 ws.send(
                   JSON.stringify({
                     id: msg.id,
-                    result: this.listBrowsers()
+                    result: this.listSims()
                   })
                 );
               }
@@ -2930,8 +3601,8 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
               return;
             }
             if (msg.type === "bridge:claim") {
-              const targetBrowser2 = await this.waitForBrowser(msg.browserId);
-              const outcome = this.tryAcquireLease(ws, targetBrowser2, {
+              const targetSim2 = await this.waitForSim(msg.simId);
+              const outcome = this.tryAcquireLease(ws, targetSim2, {
                 force: msg.force === true
               });
               if (!outcome.granted) {
@@ -2939,25 +3610,25 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
                   ws.send(
                     JSON.stringify({
                       id: msg.id,
-                      error: `tab ${targetBrowser2.id} is locked by another cli`,
+                      error: `sim ${targetSim2.id} is locked by another cli`,
                       _locked: outcome.lock
                     })
                   );
                 }
                 return;
               }
-              this.setCliBrowserTarget(ws, targetBrowser2.id);
-              this.recordBrowserAction(
-                targetBrowser2.id,
-                outcome.bootedCount > 0 ? `cli force-claimed tab (booted ${outcome.bootedCount})` : "cli claimed tab"
+              this.setCliSimTarget(ws, targetSim2.id);
+              this.recordSimAction(
+                targetSim2.id,
+                outcome.bootedCount > 0 ? `cli force-claimed sim (booted ${outcome.bootedCount})` : "cli claimed sim"
               );
               if (ws.readyState === import_ws.WebSocket.OPEN) {
                 ws.send(
                   JSON.stringify({
                     id: msg.id,
                     result: {
-                      browserId: targetBrowser2.id,
-                      lockedBy: outcome.lease.cliSessionKey,
+                      simId: targetSim2.id,
+                      lockedBy: outcome.lease.cliIdentityKey,
                       lockExpiresAt: outcome.lease.expiresAt,
                       bootedCount: outcome.bootedCount
                     }
@@ -2966,15 +3637,15 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
               }
               return;
             }
-            const targetBrowser = await this.waitForBrowser(msg.browserId);
+            const targetSim = await this.waitForSim(msg.simId);
             if (shouldAcquireLease(msg)) {
-              const outcome = this.tryAcquireLease(ws, targetBrowser);
+              const outcome = this.tryAcquireLease(ws, targetSim);
               if (!outcome.granted) {
                 if (ws.readyState === import_ws.WebSocket.OPEN) {
                   ws.send(
                     JSON.stringify({
                       id: msg.id,
-                      error: `tab ${targetBrowser.id} is locked by another cli \u2014 use \`sootsim claim ${targetBrowser.id} --force\` or \`sootsim open --new\``,
+                      error: `sim ${targetSim.id} is locked by another cli \u2014 use \`sootsim claim ${targetSim.id} --force\` or \`sootsim open --new\``,
                       _locked: outcome.lock
                     })
                   );
@@ -2982,18 +3653,18 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
                 return;
               }
             } else {
-              this.ensureCliSessionKey(ws);
+              this.ensureCliIdentityKey(ws);
             }
-            this.setCliBrowserTarget(ws, targetBrowser.id);
-            this.recordBrowserAction(targetBrowser.id, this.describeForwardedCommand(msg));
+            this.setCliSimTarget(ws, targetSim.id);
+            this.recordSimAction(targetSim.id, this.describeForwardedCommand(msg));
             const sentId = this.nextCommandId++;
             this.cliBySentId.set(sentId, {
-              browserId: targetBrowser.id,
+              simId: targetSim.id,
               ws,
               originalId: msg.id
             });
-            const { browserId: _browserId, ...forwarded } = msg;
-            targetBrowser.ws.send(JSON.stringify({ ...forwarded, id: sentId }));
+            const { simId: _simId, ...forwarded } = msg;
+            targetSim.ws.send(JSON.stringify({ ...forwarded, id: sentId }));
           } catch (err) {
             if (ws.readyState === import_ws.WebSocket.OPEN) {
               ws.send(
@@ -3008,40 +3679,40 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
       });
       ws.on("close", () => {
         this.agentHost.unregisterSocket(ws);
-        if (role === "browser" && browser) {
-          this.rememberDisconnectedBrowser(browser);
-          if (this.primaryBrowserId === browser.id) {
-            this.primaryBrowserId = this.getOpenBrowser()?.id ?? null;
+        if (role === "sim" && sim) {
+          this.rememberDisconnectedSim(sim);
+          if (this.primarySimId === sim.id) {
+            this.primarySimId = this.getOpenSim()?.id ?? null;
           }
           for (const [id, pending] of this.pendingCommands) {
-            if (pending.browserId !== browser.id) continue;
-            pending.reject(new Error("browser disconnected"));
+            if (pending.simId !== sim.id) continue;
+            pending.reject(new Error("sim disconnected"));
             this.pendingCommands.delete(id);
           }
           for (const [sentId, entry] of this.cliBySentId) {
-            if (entry.browserId !== browser.id) continue;
+            if (entry.simId !== sim.id) continue;
             if (entry.ws.readyState === import_ws.WebSocket.OPEN) {
               entry.ws.send(
                 JSON.stringify({
                   id: entry.originalId,
-                  error: "browser disconnected before responding"
+                  error: "sim disconnected before responding"
                 })
               );
             }
             this.cliBySentId.delete(sentId);
           }
-          this.broadcastBrowserAssignments();
-          this.broadcastBrowserClientStates();
+          this.broadcastSimAssignments();
+          this.broadcastSimClientStates();
         } else if (role === "cli") {
-          const detached = this.cliBrowserBySocket.delete(ws);
+          const detached = this.cliSimBySocket.delete(ws);
           this.cliLastCommandAt.delete(ws);
-          this.cliSessionKeyBySocket.delete(ws);
+          this.cliIdentityKeyBySocket.delete(ws);
           this.cliLabelBySocket.delete(ws);
           for (const [sentId, entry] of this.cliBySentId) {
             if (entry.ws === ws) this.cliBySentId.delete(sentId);
           }
           if (detached) {
-            this.broadcastBrowserClientStates();
+            this.broadcastSimClientStates();
           }
         }
       });
@@ -3059,6 +3730,11 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
       3e4
     );
     this.cliIdleTimer.unref();
+    this.wsHeartbeatTimer = setInterval(
+      () => this.sweepDeadWebSockets(),
+      _SootSimBridgeHost.WS_HEARTBEAT_INTERVAL_MS
+    );
+    this.wsHeartbeatTimer.unref();
     if (this.shouldWriteLockfile) {
       try {
         ensureSootsimHome();
@@ -3108,6 +3784,46 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
     this.activeRuntimeVersion = readActiveRuntime();
     this.activeRuntimeDirPath = activeRuntimeDir();
   }
+  runServerScan() {
+    if (this.inflightScan) return this.inflightScan;
+    const excludePorts = this.effectivePort > 0 ? [this.effectivePort] : [];
+    this.inflightScan = scanDevServers({
+      excludePorts,
+      buildIconProxyUrl: (externalUrl) => `/__bundle-proxy?url=${encodeURIComponent(externalUrl)}`
+    }).then((results) => {
+      this.scanCache = results;
+      this.scanCacheAt = Date.now();
+      return results;
+    }).catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error("[sootsim] /__server-scan failed:", message);
+      return this.scanCache ?? [];
+    }).finally(() => {
+      this.inflightScan = null;
+    });
+    return this.inflightScan;
+  }
+  handleServerScan(res) {
+    const sendJson = (body) => {
+      res.writeHead(200, {
+        "Content-Type": "application/json; charset=utf-8",
+        "Cache-Control": "no-store"
+      });
+      res.end(JSON.stringify(body));
+    };
+    const age = Date.now() - this.scanCacheAt;
+    if (this.scanCache && age < _SootSimBridgeHost.SCAN_FRESH_MS) {
+      sendJson(this.scanCache);
+      return;
+    }
+    if (this.scanCache) {
+      sendJson(this.scanCache);
+      void this.runServerScan().catch(() => {
+      });
+      return;
+    }
+    void this.runServerScan().then((results) => sendJson(results));
+  }
   resolveRuntimeUpdateIntervalMs() {
     const raw = Number(process.env[RUNTIME_UPDATE_INTERVAL_ENV]);
     if (Number.isFinite(raw) && raw > 0) return Math.max(100, Math.round(raw));
@@ -3165,7 +3881,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
   }
   /** update the active runtime on disk + in memory. the caller guarantees
    *  the version directory exists. pushes a runtime:changed message to all
-   *  connected browsers so electron (or any renderer) can reload. */
+   *  connected sims so electron (or any renderer) can reload. */
   setActiveRuntime(version) {
     writeActiveRuntime(version);
     this.refreshActiveRuntime();
@@ -3180,10 +3896,10 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
       version,
       runtimeDir: this.activeRuntimeDirPath
     });
-    for (const browser of this.browsers.values()) {
-      if (browser.ws.readyState === import_ws.WebSocket.OPEN) {
+    for (const sim of this.sims.values()) {
+      if (sim.ws.readyState === import_ws.WebSocket.OPEN) {
         try {
-          browser.ws.send(payload);
+          sim.ws.send(payload);
         } catch {
         }
       }
@@ -3212,6 +3928,13 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
    *  non-upgrade routes that don't match serve index.html (SPA behavior) so
    *  electron's webContents can navigate freely inside the runtime. */
   handleHttpRequest(req, res) {
+    if (isFetchProxyRequestUrl(req.url)) {
+      void handleFetchProxyRequest(req, res);
+      return;
+    }
+    if (isAppApiRequestUrl(req.url) && handleAppApiRequest(req, res)) {
+      return;
+    }
     const method = (req.method || "GET").toUpperCase();
     if (method !== "GET" && method !== "HEAD") {
       res.writeHead(405, { Allow: "GET, HEAD" });
@@ -3271,6 +3994,10 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
       })();
       return;
     }
+    if (url.pathname === "/__server-scan") {
+      this.handleServerScan(res);
+      return;
+    }
     if (url.pathname === "/healthz") {
       res.writeHead(200, {
         "Content-Type": "application/json",
@@ -3290,6 +4017,24 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
       );
       return;
     }
+    if (url.pathname === "/__sootsim/shared-config") {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Cache-Control", "no-store");
+      if (method === "GET" || method === "HEAD") {
+        let body = "{}";
+        try {
+          body = JSON.stringify(readSharedConfig());
+        } catch {
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        if (method === "HEAD") res.end();
+        else res.end(body);
+        return;
+      }
+      res.writeHead(405, { Allow: "GET, HEAD" });
+      res.end("method not allowed (use the bridge over WS for writes)");
+      return;
+    }
     this.refreshActiveRuntime();
     const baseDir = this.activeRuntimeDirPath;
     if (!baseDir) {
@@ -3320,41 +4065,46 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
         return;
       }
     }
-    const resolved = import_path4.default.resolve(baseDir, "." + rel);
-    const baseWithSep = baseDir.endsWith(import_path4.default.sep) ? baseDir : baseDir + import_path4.default.sep;
+    const resolved = import_path3.default.resolve(baseDir, "." + rel);
+    const baseWithSep = baseDir.endsWith(import_path3.default.sep) ? baseDir : baseDir + import_path3.default.sep;
     if (!resolved.startsWith(baseWithSep) && resolved !== baseDir) {
       res.writeHead(403);
       res.end("forbidden");
       return;
     }
-    import_fs4.default.realpath(resolved, (realErr, realResolved) => {
+    import_fs3.default.realpath(resolved, (realErr, realResolved) => {
       const servePath = realErr ? resolved : realResolved;
-      const servePathWithSep = servePath.endsWith(import_path4.default.sep) ? servePath : servePath + import_path4.default.sep;
+      const servePathWithSep = servePath.endsWith(import_path3.default.sep) ? servePath : servePath + import_path3.default.sep;
       if (!realErr) {
         const realBaseWithSep = (() => {
           try {
-            const rb = import_fs4.default.realpathSync(baseDir);
-            return rb.endsWith(import_path4.default.sep) ? rb : rb + import_path4.default.sep;
+            const rb = import_fs3.default.realpathSync(baseDir);
+            return rb.endsWith(import_path3.default.sep) ? rb : rb + import_path3.default.sep;
           } catch {
             return baseWithSep;
           }
         })();
-        if (!servePathWithSep.startsWith(realBaseWithSep) && servePath + import_path4.default.sep !== realBaseWithSep) {
+        if (!servePathWithSep.startsWith(realBaseWithSep) && servePath + import_path3.default.sep !== realBaseWithSep) {
           res.writeHead(403);
           res.end("forbidden");
           return;
         }
       }
-      import_fs4.default.stat(servePath, (err, stats) => {
+      import_fs3.default.stat(servePath, (err, stats) => {
         if (err || !stats?.isFile()) {
-          const ext2 = import_path4.default.extname(rel).toLowerCase();
+          const ext2 = import_path3.default.extname(rel).toLowerCase();
           if (ext2 && ext2 !== ".html") {
             res.writeHead(404);
             res.end("not found");
             return;
           }
-          const indexPath = import_path4.default.join(baseDir, "index.html");
-          import_fs4.default.readFile(indexPath, (err2, data) => {
+          if (rel.startsWith("/__") || rel.startsWith("/api/") || rel === "/api") {
+            res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+            res.end("not found");
+            return;
+          }
+          const indexPath = import_path3.default.join(baseDir, "index.html");
+          import_fs3.default.readFile(indexPath, (err2, data) => {
             if (err2) {
               res.writeHead(404);
               res.end("not found");
@@ -3368,11 +4118,11 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
               res.end();
               return;
             }
-            res.end(data);
+            res.end(injectSharedConfigIntoHtml(data));
           });
           return;
         }
-        const ext = import_path4.default.extname(servePath).toLowerCase();
+        const ext = import_path3.default.extname(servePath).toLowerCase();
         const contentType = HTTP_MIME_TYPES[ext] || "application/octet-stream";
         res.writeHead(200, {
           "Content-Type": contentType,
@@ -3382,7 +4132,20 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
           res.end();
           return;
         }
-        const stream = import_fs4.default.createReadStream(servePath);
+        if (ext === ".html") {
+          import_fs3.default.readFile(servePath, (readErr, data) => {
+            if (readErr) {
+              try {
+                res.end();
+              } catch {
+              }
+              return;
+            }
+            res.end(injectSharedConfigIntoHtml(data));
+          });
+          return;
+        }
+        const stream = import_fs3.default.createReadStream(servePath);
         stream.pipe(res);
         stream.on("error", () => {
           try {
@@ -3396,10 +4159,10 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
   sweepIdleCliClients() {
     const now = Date.now();
     let swept = false;
-    for (const [ws, browserId] of this.cliBrowserBySocket) {
+    for (const [ws, simId] of this.cliSimBySocket) {
       const lastCommand = this.cliLastCommandAt.get(ws) ?? 0;
       if (now - lastCommand < _SootSimBridgeHost.CLI_IDLE_TIMEOUT_MS) continue;
-      this.cliBrowserBySocket.delete(ws);
+      this.cliSimBySocket.delete(ws);
       this.cliLastCommandAt.delete(ws);
       for (const [sentId, entry] of this.cliBySentId) {
         if (entry.ws === ws) this.cliBySentId.delete(sentId);
@@ -3411,54 +4174,80 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
       swept = true;
     }
     if (swept) {
-      this.broadcastBrowserClientStates();
+      this.broadcastSimClientStates();
+    }
+    this.sweepRestorableSims(now);
+  }
+  // ping every connected ws; if the previous round's ping went unanswered,
+  // terminate the socket so 'close' fires and the sim cleanup path
+  // runs. matches the recommended ws-library heartbeat pattern.
+  sweepDeadWebSockets() {
+    if (!this.wss) return;
+    for (const ws of this.wss.clients) {
+      if (ws.readyState !== import_ws.WebSocket.OPEN) continue;
+      const alive = this.wsIsAlive.get(ws);
+      if (alive === false) {
+        try {
+          ws.terminate();
+        } catch {
+        }
+        continue;
+      }
+      this.wsIsAlive.set(ws, false);
+      try {
+        ws.ping();
+      } catch {
+        try {
+          ws.terminate();
+        } catch {
+        }
+      }
     }
-    this.sweepRestorableBrowsers(now);
   }
-  listBrowsers() {
-    return Array.from(this.browsers.values()).sort((a, b) => {
-      if (a.id === this.primaryBrowserId) return -1;
-      if (b.id === this.primaryBrowserId) return 1;
+  listSims() {
+    return Array.from(this.sims.values()).sort((a, b) => {
+      if (a.id === this.primarySimId) return -1;
+      if (b.id === this.primarySimId) return 1;
       return a.connectedAt - b.connectedAt;
-    }).map((browser) => this.describeBrowser(browser));
+    }).map((sim) => this.describeSim(sim));
   }
   async sendCommand(cmd) {
-    const browser = await this.waitForBrowser(cmd.browserId);
+    const sim = await this.waitForSim(cmd.simId);
     const id = this.nextCommandId++;
     return new Promise((resolve2, reject) => {
       const timeout = setTimeout(() => {
         this.pendingCommands.delete(id);
-        this.broadcastBrowserClientStates();
+        this.broadcastSimClientStates();
         reject(new Error("command timed out after 30s"));
       }, 3e4);
       this.pendingCommands.set(id, {
-        browserId: browser.id,
+        simId: sim.id,
         resolve: (value) => {
           clearTimeout(timeout);
           this.pendingCommands.delete(id);
-          this.broadcastBrowserClientStates();
+          this.broadcastSimClientStates();
           resolve2(value);
         },
         reject: (error) => {
           clearTimeout(timeout);
           this.pendingCommands.delete(id);
-          this.broadcastBrowserClientStates();
+          this.broadcastSimClientStates();
           reject(error);
         }
       });
-      this.broadcastBrowserClientStates();
-      const { browserId: _browserId, ...forwarded } = cmd;
-      browser.ws.send(JSON.stringify({ ...forwarded, id }));
+      this.broadcastSimClientStates();
+      const { simId: _simId, ...forwarded } = cmd;
+      sim.ws.send(JSON.stringify({ ...forwarded, id }));
     });
   }
-  async evaluate(code, browserId) {
-    return this.sendCommand({ type: "evaluate", code, browserId });
+  async evaluate(code, simId) {
+    return this.sendCommand({ type: "evaluate", code, simId });
   }
-  async focusBrowser(browserId) {
-    return this.sendCommand({ type: "focus", browserId });
+  async focusSim(simId) {
+    return this.sendCommand({ type: "focus", simId });
   }
-  async closeBrowser(browserId) {
-    return this.sendCommand({ type: "close", browserId });
+  async closeSim(simId) {
+    return this.sendCommand({ type: "close", simId });
   }
   async openPathInEditor(filePath, line, column) {
     const loc = line != null ? `:${line}${column != null ? `:${column}` : ""}` : "";
@@ -3508,6 +4297,10 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
       clearInterval(this.heartbeatTimer);
       this.heartbeatTimer = null;
     }
+    if (this.wsHeartbeatTimer) {
+      clearInterval(this.wsHeartbeatTimer);
+      this.wsHeartbeatTimer = null;
+    }
     if (this.runtimeUpdateTimer) {
       clearInterval(this.runtimeUpdateTimer);
       this.runtimeUpdateTimer = null;
@@ -3525,11 +4318,11 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
       pending.reject(new Error("server closing"));
       this.pendingCommands.delete(id);
     }
-    for (const browser of this.browsers.values()) {
-      browser.ws.close();
+    for (const sim of this.sims.values()) {
+      sim.ws.close();
     }
-    this.browsers.clear();
-    this.primaryBrowserId = null;
+    this.sims.clear();
+    this.primarySimId = null;
     const wss = this.wss;
     const httpServer = this.httpServer;
     this.wss = null;
@@ -3547,69 +4340,69 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
       }
     }
   }
-  describeBrowser(browser) {
+  describeSim(sim) {
     let readyState;
     try {
-      readyState = browser.ws.readyState;
+      readyState = sim.ws.readyState;
     } catch {
       readyState = import_ws.WebSocket.CLOSED;
     }
-    const lease = this.getActiveLease(browser);
+    const lease = this.getActiveLease(sim);
     return {
-      id: browser.id,
-      origin: browser.origin,
-      url: browser.url,
-      title: browser.title,
-      userAgent: browser.userAgent,
-      connectedAt: browser.connectedAt,
-      lastSeenAt: browser.lastSeenAt,
-      lastActiveAt: browser.lastActiveAt || void 0,
-      isPrimary: browser.id === this.primaryBrowserId,
+      id: sim.id,
+      origin: sim.origin,
+      url: sim.url,
+      title: sim.title,
+      userAgent: sim.userAgent,
+      connectedAt: sim.connectedAt,
+      lastSeenAt: sim.lastSeenAt,
+      lastActiveAt: sim.lastActiveAt || void 0,
+      isPrimary: sim.id === this.primarySimId,
       readyState: readyState === import_ws.WebSocket.OPEN ? "open" : readyState === import_ws.WebSocket.CLOSING ? "closing" : "closed",
-      attachedCliCount: this.getAttachedCliCount(browser.id),
-      lockedBy: lease ? lease.cliLabel || lease.cliSessionKey : void 0,
+      attachedCliCount: this.getAttachedCliCount(sim.id),
+      lockedBy: lease ? lease.cliLabel || lease.cliIdentityKey : void 0,
       lockedByKind: lease ? lease.kind : void 0,
       lockExpiresAt: lease ? lease.expiresAt : void 0,
-      userFocused: browser.userFocused || void 0
+      userFocused: sim.userFocused || void 0
     };
   }
-  getActiveLease(browser) {
-    const lease = browser.cliLease;
+  getActiveLease(sim) {
+    const lease = sim.cliLease;
     if (!lease) return null;
     if (Date.now() >= lease.expiresAt) {
-      browser.cliLease = void 0;
+      sim.cliLease = void 0;
       return null;
     }
     return lease;
   }
-  tryAcquireLease(ws, browser, opts = {}) {
-    const cliSessionKey = this.cliSessionKeyBySocket.get(ws) ?? (() => {
+  tryAcquireLease(ws, sim, opts = {}) {
+    const cliIdentityKey = this.cliIdentityKeyBySocket.get(ws) ?? (() => {
       const fallback = `ws-${this.nextCliFallbackId++}`;
-      this.cliSessionKeyBySocket.set(ws, fallback);
+      this.cliIdentityKeyBySocket.set(ws, fallback);
       return fallback;
     })();
     const cliLabel = this.cliLabelBySocket.get(ws);
     const now = Date.now();
-    const existing = this.getActiveLease(browser);
-    const ownerMatches = existing && existing.cliSessionKey === cliSessionKey;
+    const existing = this.getActiveLease(sim);
+    const ownerMatches = existing && existing.cliIdentityKey === cliIdentityKey;
     let bootedCount = 0;
     if (existing && !ownerMatches && !opts.force) {
       return {
         granted: false,
         lease: existing,
         lock: {
-          by: existing.cliLabel || existing.cliSessionKey,
+          by: existing.cliLabel || existing.cliIdentityKey,
           expiresInMs: Math.max(0, existing.expiresAt - now)
         },
         bootedCount: 0
       };
     }
     if (existing && !ownerMatches && opts.force) {
-      for (const [cliWs, attachedBrowserId] of this.cliBrowserBySocket) {
-        if (attachedBrowserId !== browser.id) continue;
-        const otherKey = this.cliSessionKeyBySocket.get(cliWs);
-        if (otherKey && otherKey !== cliSessionKey) {
-          this.cliBrowserBySocket.delete(cliWs);
+      for (const [cliWs, attachedSimId] of this.cliSimBySocket) {
+        if (attachedSimId !== sim.id) continue;
+        const otherKey = this.cliIdentityKeyBySocket.get(cliWs);
+        if (otherKey && otherKey !== cliIdentityKey) {
+          this.cliSimBySocket.delete(cliWs);
           try {
             cliWs.close(1e3, "lease claimed by another cli");
           } catch {
@@ -3620,135 +4413,129 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
     }
     const lease = {
       kind: "cli",
-      cliSessionKey,
+      cliIdentityKey,
       cliLabel,
       expiresAt: now + _SootSimBridgeHost.CLI_LEASE_TTL_MS
     };
-    browser.cliLease = lease;
+    sim.cliLease = lease;
     return { granted: true, lease, bootedCount };
   }
-  // user focus is advisory: we track it on the browser record so list/UI can
+  // user focus is advisory: we track it on the sim record so list/UI can
   // show "focused" alongside any cli lease, but focus alone never creates a
-  // blocking lease. the old 15s user-focus lease meant clicking on the tab
+  // blocking lease. the old 15s user-focus lease meant clicking on the sim
   // locked out agent inspect calls for 15s — the opposite of what you want
   // when debugging something the user is actively looking at. use
   // updateUserActivity() to lock on real interaction instead.
-  updateUserFocusLease(browser, focused) {
+  updateUserFocusLease(sim, focused) {
     const next = focused;
-    if (browser.userFocused === next) return;
-    browser.userFocused = next;
-    this.broadcastBrowserClientStates();
+    if (sim.userFocused === next) return;
+    sim.userFocused = next;
+    this.broadcastSimClientStates();
   }
-  // called when the browser reports a real user interaction (pointerdown,
+  // called when the sim reports a real user interaction (pointerdown,
   // keydown, wheel, touch). creates or refreshes a short `user-active` lease
-  // that keeps agent writes from trampling a user who is driving the tab.
+  // that keeps agent writes from trampling a user who is driving the sim.
   // reads still pass through — shouldAcquireLease only blocks on writes.
-  updateUserActivity(browser) {
-    const existing = this.getActiveLease(browser);
+  updateUserActivity(sim) {
+    const existing = this.getActiveLease(sim);
     if (existing && existing.kind === "cli") {
       return;
     }
     const now = Date.now();
     const refreshed = now + _SootSimBridgeHost.USER_ACTIVE_LEASE_TTL_MS;
     const expiresAt = existing && existing.kind === "user-active" ? Math.max(existing.expiresAt, refreshed) : refreshed;
-    browser.cliLease = {
+    sim.cliLease = {
       kind: "user-active",
-      cliSessionKey: "__user-active__",
+      cliIdentityKey: "__user-active__",
       cliLabel: "active user",
       expiresAt
     };
-    this.broadcastBrowserClientStates();
+    this.broadcastSimClientStates();
   }
-  ensureCliSessionKey(ws) {
-    const existing = this.cliSessionKeyBySocket.get(ws);
+  ensureCliIdentityKey(ws) {
+    const existing = this.cliIdentityKeyBySocket.get(ws);
     if (existing) return existing;
     const fallback = `ws-${this.nextCliFallbackId++}`;
-    this.cliSessionKeyBySocket.set(ws, fallback);
+    this.cliIdentityKeyBySocket.set(ws, fallback);
     return fallback;
   }
-  getOpenBrowser(browserId) {
-    if (browserId) {
-      const browser = this.browsers.get(browserId);
-      if (browser?.ws.readyState === import_ws.WebSocket.OPEN) return browser;
+  getOpenSim(simId) {
+    if (simId) {
+      const sim = this.sims.get(simId);
+      if (sim?.ws.readyState === import_ws.WebSocket.OPEN) return sim;
       return null;
     }
-    const primary = this.primaryBrowserId != null ? this.browsers.get(this.primaryBrowserId) : null;
+    const primary = this.primarySimId != null ? this.sims.get(this.primarySimId) : null;
     if (primary?.ws.readyState === import_ws.WebSocket.OPEN) return primary;
-    for (const browser of this.browsers.values()) {
-      if (browser.ws.readyState === import_ws.WebSocket.OPEN) return browser;
+    for (const sim of this.sims.values()) {
+      if (sim.ws.readyState === import_ws.WebSocket.OPEN) return sim;
     }
     return null;
   }
-  async waitForBrowser(browserId, options = {}) {
+  async waitForSim(simId, options = {}) {
     const attempts = options.attempts ?? 10;
     const intervalMs = options.intervalMs ?? 200;
     for (let attempt = 0; attempt < attempts; attempt++) {
-      const browser = this.getOpenBrowser(browserId);
-      if (browser) return browser;
+      const sim = this.getOpenSim(simId);
+      if (sim) return sim;
       await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
     }
-    throw new Error(
-      browserId ? `no browser connected with id ${browserId}` : "no browser connected"
-    );
+    throw new Error(simId ? `no sim connected with id ${simId}` : "no sim connected");
   }
-  shouldPromoteBrowser(browser) {
-    const current = this.primaryBrowserId ? this.browsers.get(this.primaryBrowserId) : null;
-    const isPrimaryCandidate = browser.origin?.includes(":5173");
+  shouldPromoteSim(sim) {
+    const current = this.primarySimId ? this.sims.get(this.primarySimId) : null;
+    const isPrimaryCandidate = sim.origin?.includes(":5173");
     const currentIsPrimary = current?.origin?.includes(":5173");
     return !current || current.ws.readyState !== import_ws.WebSocket.OPEN || !!isPrimaryCandidate || !currentIsPrimary;
   }
-  broadcastBrowserAssignments() {
-    for (const browser of this.browsers.values()) {
-      if (browser.ws.readyState !== import_ws.WebSocket.OPEN) continue;
-      browser.ws.send(
+  broadcastSimAssignments() {
+    for (const sim of this.sims.values()) {
+      if (sim.ws.readyState !== import_ws.WebSocket.OPEN) continue;
+      sim.ws.send(
         JSON.stringify({
           type: "bridge:welcome",
-          browserId: browser.id,
-          isPrimary: browser.id === this.primaryBrowserId
+          simId: sim.id,
+          isPrimary: sim.id === this.primarySimId
         })
       );
     }
   }
-  broadcastBrowserClientStates() {
-    for (const browser of this.browsers.values()) {
-      if (browser.ws.readyState !== import_ws.WebSocket.OPEN) continue;
-      const lease = this.getActiveLease(browser);
+  broadcastSimClientStates() {
+    for (const sim of this.sims.values()) {
+      if (sim.ws.readyState !== import_ws.WebSocket.OPEN) continue;
+      const lease = this.getActiveLease(sim);
       const message = {
         type: "bridge:client-state",
-        attachedCliCount: this.getAttachedCliCount(browser.id),
-        activeAgentCommandCount: this.getActiveAgentCommandCount(browser.id),
-        recentActions: browser.recentActions,
-        lockedBy: lease ? lease.cliLabel || lease.cliSessionKey : void 0,
+        attachedCliCount: this.getAttachedCliCount(sim.id),
+        activeAgentCommandCount: this.getActiveAgentCommandCount(sim.id),
+        recentActions: sim.recentActions,
+        lockedBy: lease ? lease.cliLabel || lease.cliIdentityKey : void 0,
         lockedByKind: lease ? lease.kind : void 0,
         lockExpiresAt: lease ? lease.expiresAt : void 0,
-        userFocused: browser.userFocused || void 0
+        userFocused: sim.userFocused || void 0
       };
-      browser.ws.send(JSON.stringify(message));
+      sim.ws.send(JSON.stringify(message));
     }
   }
-  setCliBrowserTarget(ws, browserId) {
-    const prevBrowserId = this.cliBrowserBySocket.get(ws);
-    if (prevBrowserId === browserId) return;
-    this.cliBrowserBySocket.set(ws, browserId);
-    this.recordBrowserAction(
-      browserId,
-      prevBrowserId ? "cli switched tabs" : "cli connected",
-      false
-    );
-    this.broadcastBrowserClientStates();
+  setCliSimTarget(ws, simId) {
+    const prevSimId = this.cliSimBySocket.get(ws);
+    if (prevSimId === simId) return;
+    this.cliSimBySocket.set(ws, simId);
+    this.recordSimAction(simId, prevSimId ? "cli switched sims" : "cli connected", false);
+    this.broadcastSimClientStates();
   }
-  recordBrowserAction(browserId, label, broadcast = true) {
+  recordSimAction(simId, label, broadcast = true) {
     const normalized = label?.trim();
     if (!normalized) return;
-    const browser = this.browsers.get(browserId);
-    if (!browser) return;
+    const sim = this.sims.get(simId);
+    if (!sim) return;
     const now = Date.now();
-    browser.lastActiveAt = now;
-    browser.recentActions = [
+    sim.lastActiveAt = now;
+    sim.recentActions = [
       { label: normalized, at: now },
-      ...browser.recentActions.filter((entry) => entry.label !== normalized)
+      ...sim.recentActions.filter((entry) => entry.label !== normalized)
     ].slice(0, 4);
-    if (broadcast) this.broadcastBrowserClientStates();
+    if (broadcast) this.broadcastSimClientStates();
   }
   describeForwardedCommand(msg) {
     switch (msg?.type) {
@@ -3763,90 +4550,97 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
       case "tree":
         return "dumped tree";
       case "focus":
-        return "focused tab";
+        return "focused sim";
       case "close":
         return "requested close";
       default:
         return typeof msg?.type === "string" ? msg.type : null;
     }
   }
-  // count distinct cli session keys attached to a browser, not raw sockets.
+  // count distinct cli identity keys attached to a sim, not raw sockets.
   // a single agent firing sequential cli commands opens a new ws per call —
   // counting sockets would report phantom peers until idle cleanup catches up.
-  getAttachedCliCount(browserId) {
+  getAttachedCliCount(simId) {
     const keys = /* @__PURE__ */ new Set();
-    for (const [ws, attachedBrowserId] of this.cliBrowserBySocket) {
-      if (attachedBrowserId !== browserId) continue;
+    for (const [ws, attachedSimId] of this.cliSimBySocket) {
+      if (attachedSimId !== simId) continue;
       if (ws.readyState !== import_ws.WebSocket.OPEN) continue;
-      const key = this.cliSessionKeyBySocket.get(ws);
+      const key = this.cliIdentityKeyBySocket.get(ws);
       keys.add(key ?? `ws-unknown-${keys.size}`);
     }
     return keys.size;
   }
-  // count distinct session keys attached to this browser other than `selfWs`.
-  // used to warn a cli that other agents/sessions are also targeting the tab.
-  getOtherCliSessionCount(selfWs, browserId) {
-    const selfKey = this.cliSessionKeyBySocket.get(selfWs);
+  // count distinct identity keys attached to this sim other than `selfWs`.
+  // used to warn a cli that other agents/identities are also targeting the sim.
+  getOtherCliIdentityCount(selfWs, simId) {
+    const selfKey = this.cliIdentityKeyBySocket.get(selfWs);
     const keys = /* @__PURE__ */ new Set();
-    for (const [ws, attachedBrowserId] of this.cliBrowserBySocket) {
-      if (attachedBrowserId !== browserId) continue;
+    for (const [ws, attachedSimId] of this.cliSimBySocket) {
+      if (attachedSimId !== simId) continue;
       if (ws.readyState !== import_ws.WebSocket.OPEN) continue;
-      const key = this.cliSessionKeyBySocket.get(ws);
+      const key = this.cliIdentityKeyBySocket.get(ws);
       if (key && key === selfKey) continue;
       keys.add(key ?? `ws-unknown-${keys.size}`);
     }
     return keys.size;
   }
-  getActiveAgentCommandCount(browserId) {
+  getActiveAgentCommandCount(simId) {
     let count = 0;
     for (const pending of this.pendingCommands.values()) {
-      if (pending.browserId === browserId) count++;
+      if (pending.simId === simId) count++;
     }
     return count;
   }
-  tryRestoreBrowserId(browser, requestedId) {
+  allocateSimId() {
+    for (; ; ) {
+      const id = this.nextSimNumber.toString(16);
+      this.nextSimNumber++;
+      if (!this.sims.has(id) && !this.restorableSims.has(id)) return id;
+    }
+  }
+  tryRestoreSimId(sim, requestedId) {
     const nextId = requestedId?.trim();
-    if (!nextId || nextId === browser.id) return false;
-    const existing = this.browsers.get(nextId);
-    if (existing && existing !== browser && existing.ws.readyState === import_ws.WebSocket.OPEN) {
+    if (!nextId || nextId === sim.id) return false;
+    const existing = this.sims.get(nextId);
+    if (existing && existing !== sim && existing.ws.readyState === import_ws.WebSocket.OPEN) {
       return false;
     }
-    const restorable = this.getRestorableBrowserState(nextId);
-    const prevId = browser.id;
-    this.browsers.delete(prevId);
-    browser.id = nextId;
+    const restorable = this.getRestorableSimState(nextId);
+    const prevId = sim.id;
+    this.sims.delete(prevId);
+    sim.id = nextId;
     if (restorable) {
-      browser.recentActions = restorable.recentActions.map((entry) => ({ ...entry }));
-      browser.lastActiveAt = restorable.lastActiveAt;
-      browser.cliLease = restorable.cliLease ? { ...restorable.cliLease } : void 0;
-      this.restorableBrowsers.delete(nextId);
+      sim.recentActions = restorable.recentActions.map((entry) => ({ ...entry }));
+      sim.lastActiveAt = restorable.lastActiveAt;
+      sim.cliLease = restorable.cliLease ? { ...restorable.cliLease } : void 0;
+      this.restorableSims.delete(nextId);
     }
-    this.browsers.set(browser.id, browser);
-    if (this.primaryBrowserId === prevId) {
-      this.primaryBrowserId = browser.id;
+    this.sims.set(sim.id, sim);
+    if (this.primarySimId === prevId) {
+      this.primarySimId = sim.id;
     }
-    for (const [ws, attachedBrowserId] of this.cliBrowserBySocket) {
-      if (attachedBrowserId === prevId) {
-        this.cliBrowserBySocket.set(ws, browser.id);
+    for (const [ws, attachedSimId] of this.cliSimBySocket) {
+      if (attachedSimId === prevId) {
+        this.cliSimBySocket.set(ws, sim.id);
       }
     }
     return true;
   }
-  rememberDisconnectedBrowser(browser) {
-    const lease = this.getActiveLease(browser);
-    this.restorableBrowsers.set(browser.id, {
-      recentActions: browser.recentActions.map((entry) => ({ ...entry })),
-      lastActiveAt: browser.lastActiveAt,
+  rememberDisconnectedSim(sim) {
+    const lease = this.getActiveLease(sim);
+    this.restorableSims.set(sim.id, {
+      recentActions: sim.recentActions.map((entry) => ({ ...entry })),
+      lastActiveAt: sim.lastActiveAt,
       cliLease: lease && lease.kind === "cli" ? { ...lease } : void 0,
-      expiresAt: Date.now() + _SootSimBridgeHost.BROWSER_RECONNECT_TTL_MS
+      expiresAt: Date.now() + _SootSimBridgeHost.SIM_RECONNECT_TTL_MS
     });
-    this.browsers.delete(browser.id);
+    this.sims.delete(sim.id);
   }
-  getRestorableBrowserState(browserId) {
-    const snapshot = this.restorableBrowsers.get(browserId);
+  getRestorableSimState(simId) {
+    const snapshot = this.restorableSims.get(simId);
     if (!snapshot) return null;
     if (snapshot.expiresAt <= Date.now()) {
-      this.restorableBrowsers.delete(browserId);
+      this.restorableSims.delete(simId);
       return null;
     }
     if (snapshot.cliLease && snapshot.cliLease.expiresAt <= Date.now()) {
@@ -3854,13 +4648,13 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
     }
     return snapshot;
   }
-  sweepRestorableBrowsers(now = Date.now()) {
-    for (const [browserId, snapshot] of this.restorableBrowsers) {
+  sweepRestorableSims(now = Date.now()) {
+    for (const [simId, snapshot] of this.restorableSims) {
       if (snapshot.expiresAt > now) continue;
-      this.restorableBrowsers.delete(browserId);
-      for (const [cliWs, attachedBrowserId] of this.cliBrowserBySocket) {
-        if (attachedBrowserId === browserId) {
-          this.cliBrowserBySocket.delete(cliWs);
+      this.restorableSims.delete(simId);
+      for (const [cliWs, attachedSimId] of this.cliSimBySocket) {
+        if (attachedSimId === simId) {
+          this.cliSimBySocket.delete(cliWs);
         }
       }
     }
@@ -3870,6 +4664,10 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
       clearInterval(this.cliIdleTimer);
       this.cliIdleTimer = null;
     }
+    if (this.wsHeartbeatTimer) {
+      clearInterval(this.wsHeartbeatTimer);
+      this.wsHeartbeatTimer = null;
+    }
     if (this.runtimeUpdateTimer) {
       clearInterval(this.runtimeUpdateTimer);
       this.runtimeUpdateTimer = null;