sootsim 0.0.1 → 0.0.2

package/dist-lib/vite-base.cjs

@@ -0,0 +1,4217 @@
+/*! sootsim v0.0.2 | (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;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/bridge-constants.ts
+var DEFAULT_SOOTSIM_BRIDGE_PORT;
+var init_bridge_constants = __esm({
+  "src/bridge-constants.ts"() {
+    "use strict";
+    DEFAULT_SOOTSIM_BRIDGE_PORT = 7668;
+  }
+});
+
+// src/home-paths.ts
+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 ensureSootsimHome() {
+  import_fs.default.mkdirSync(sootsimHomeDir(), { recursive: true });
+  import_fs.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_fs.default.mkdirSync(cacheDir(), { recursive: true });
+}
+function readActiveRuntime() {
+  try {
+    const value = import_fs.default.readFileSync(activeRuntimeFile(), "utf8").trim();
+    return value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+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 [];
+  }
+}
+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 {
+    if (import_fs.default.statSync(dir).isDirectory()) return dir;
+  } catch {
+  }
+  return null;
+}
+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;
+      }
+      return null;
+    } finally {
+      import_fs.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_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;
+  }
+  writeDaemonLockfile(data);
+  return true;
+}
+function removeDaemonLockfile() {
+  try {
+    import_fs.default.unlinkSync(daemonLockfilePath());
+  } catch {
+  }
+}
+var import_fs, import_os, import_path, SOOTSIM_HOME_ENV, ACTIVE_RUNTIME_FILE, DAEMON_LOCKFILE, DAEMON_HEARTBEAT_STALE_MS, DAEMON_LOCKFILE_MAX_BYTES;
+var init_home_paths = __esm({
+  "src/home-paths.ts"() {
+    "use strict";
+    import_fs = __toESM(require("fs"), 1);
+    import_os = require("os");
+    import_path = __toESM(require("path"), 1);
+    SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
+    ACTIVE_RUNTIME_FILE = "active";
+    DAEMON_LOCKFILE = "daemon.json";
+    DAEMON_HEARTBEAT_STALE_MS = 3e4;
+    DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
+  }
+});
+
+// src/config.ts
+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();
+}
+var SOOTSIM_CONFIG_QUERY_PARAM;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    SOOTSIM_CONFIG_QUERY_PARAM = "sootsimConfig";
+  }
+});
+
+// src/native-dev-bundle-url.ts
+function isAbsoluteHttpUrl(url) {
+  return /^https?:\/\//i.test(url);
+}
+function isNativeDevBundlePath(pathname) {
+  return pathname.endsWith(".bundle");
+}
+function normalizeNativeDevBundleUrl(bundleUrl) {
+  try {
+    const isAbsolute = isAbsoluteHttpUrl(bundleUrl);
+    const parsed = new URL(bundleUrl, "http://soot.local");
+    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");
+    }
+    if (isAbsolute) return parsed.toString();
+    return `${parsed.pathname}${parsed.search}${parsed.hash}`;
+  } catch {
+    return bundleUrl;
+  }
+}
+var init_native_dev_bundle_url = __esm({
+  "src/native-dev-bundle-url.ts"() {
+    "use strict";
+  }
+});
+
+// scripts/demo-app-registry.ts
+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 resolveWorkspaceScriptPath(workspaceRelativePath, packageRelativePath) {
+  const workspaceRoot2 = findWorkspaceRoot(process.cwd());
+  const candidates = [
+    workspaceRoot2 ? (0, import_node_path.resolve)(workspaceRoot2, 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 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;
+  }
+  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();
+    }
+  }
+  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 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
+  );
+}
+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, "");
+  }
+}
+var import_node_fs, import_node_os, import_node_path, HOME, getExpensifyProxyScript, EXPENSIFY_NATIVE_PROXY_ENV, UNISWAP_REPO_DIR, UNISWAP_APP_DIR, UNISWAP_ENV_LOCAL_FILE, UNISWAP_PLACEHOLDER, UNISWAP_DEMO_ENV_MARKER, UNISWAP_FORCE_UPGRADE_HOOK_FILE, UNISWAP_FORCE_UPGRADE_NOTIFICATION_FILE, UNISWAP_FORCE_UPGRADE_PATCH_MARKER, ARTSY_DIR, ARTSY_KEYS_FILE, ARTSY_METAFLAGS_FILE, ARTSY_RELAY_SENTINEL, APPS;
+var init_demo_app_registry = __esm({
+  "scripts/demo-app-registry.ts"() {
+    "use strict";
+    import_node_fs = require("node:fs");
+    import_node_os = require("node:os");
+    import_node_path = require("node:path");
+    HOME = (0, import_node_os.homedir)();
+    getExpensifyProxyScript = () => resolveWorkspaceScriptPath(
+      "packages/sootsim-engine/scripts/expensify-web-proxy.ts",
+      "scripts/expensify-web-proxy.ts"
+    );
+    EXPENSIFY_NATIVE_PROXY_ENV = {
+      USE_NGROK: "true",
+      NGROK_URL: "http://localhost:9000/",
+      SECURE_NGROK_URL: "http://localhost:9000/"
+    };
+    UNISWAP_REPO_DIR = (0, import_node_path.join)(HOME, "github/uniswap-interface");
+    UNISWAP_APP_DIR = (0, import_node_path.join)(UNISWAP_REPO_DIR, "apps/mobile");
+    UNISWAP_ENV_LOCAL_FILE = (0, import_node_path.join)(UNISWAP_REPO_DIR, ".env.defaults.local");
+    UNISWAP_PLACEHOLDER = "stored-in-.env.local";
+    UNISWAP_DEMO_ENV_MARKER = "# sootsim demo env overrides";
+    UNISWAP_FORCE_UPGRADE_HOOK_FILE = (0, import_node_path.join)(
+      UNISWAP_REPO_DIR,
+      "packages/uniswap/src/features/forceUpgrade/hooks/useForceUpgradeStatus.ts"
+    );
+    UNISWAP_FORCE_UPGRADE_NOTIFICATION_FILE = (0, import_node_path.join)(
+      UNISWAP_REPO_DIR,
+      "apps/mobile/src/notification-service/data-sources/createForceUpgradeNotificationDataSource.ts"
+    );
+    UNISWAP_FORCE_UPGRADE_PATCH_MARKER = "SOOTSIM_DEMO_DISABLE_FORCE_UPGRADE";
+    ARTSY_DIR = (0, import_node_path.join)(HOME, "github/eigen");
+    ARTSY_KEYS_FILE = (0, import_node_path.join)(ARTSY_DIR, "keys.shared.json");
+    ARTSY_METAFLAGS_FILE = (0, import_node_path.join)(ARTSY_DIR, "metaflags.json");
+    ARTSY_RELAY_SENTINEL = (0, import_node_path.join)(ARTSY_DIR, "src/__generated__/.relay-complete");
+    APPS = [
+      {
+        name: "bluesky",
+        label: "Bluesky",
+        dir: (0, import_node_path.join)(HOME, "github/bluesky"),
+        preferredPort: 8082,
+        framework: "expo",
+        command: (p) => ({ cmd: `npx expo start --port ${p}` }),
+        credentials: {
+          envVars: ["SOOTSIM_BLUESKY_PASSWORD"],
+          known: { HANDLE: "natew.bsky.social" }
+        }
+      },
+      {
+        name: "3pc",
+        label: "3PunchConvo",
+        dir: (0, import_node_path.join)(HOME, "lightstrike-labs/three-punch-convo-app/apps/one"),
+        preferredPort: 8081,
+        framework: "one",
+        command: (p) => ({ cmd: "npx one dev", env: { ONE_PORT: String(p) } })
+      },
+      {
+        name: "uniswap",
+        label: "Uniswap",
+        dir: UNISWAP_APP_DIR,
+        preferredPort: 8085,
+        framework: "expo",
+        prepare: () => {
+          ensureUniswapDemoEnvLocal();
+          ensureUniswapForceUpgradePatched();
+        },
+        command: (p) => ({
+          cmd: `npx expo start --clear --port ${p}`,
+          // prefer the real local mobile env when present, otherwise fall back
+          // to Uniswap's checked-in public web RPC settings so demo boots cleanly.
+          env: resolveUniswapDemoEnv()
+        })
+      },
+      {
+        name: "takeout",
+        label: "Takeout",
+        dir: (0, import_node_path.join)(HOME, "takeout"),
+        preferredPort: 8086,
+        framework: "one",
+        command: (p) => ({ cmd: "npx one dev", env: { ONE_PORT: String(p) } })
+      },
+      {
+        name: "expensify",
+        label: "Expensify",
+        dir: (0, import_node_path.join)(HOME, "github/expensify"),
+        preferredPort: 8087,
+        framework: "rock",
+        runtimeConfig: {
+          env: EXPENSIFY_NATIVE_PROXY_ENV
+        },
+        sidecars: [
+          {
+            name: "web-proxy",
+            port: 9e3,
+            readyPath: "/api/Ping",
+            command: () => ({
+              cmd: `bun ${JSON.stringify(getExpensifyProxyScript())}`,
+              env: EXPENSIFY_NATIVE_PROXY_ENV
+            })
+          }
+        ],
+        command: (p) => ({
+          cmd: `fnm exec --using=20.20.0 npx rock start --port ${p} --no-interactive`,
+          env: EXPENSIFY_NATIVE_PROXY_ENV
+        })
+      },
+      {
+        name: "artsy",
+        label: "Artsy",
+        dir: ARTSY_DIR,
+        preferredPort: 8088,
+        framework: "expo",
+        runtimeConfig: resolveArtsyRuntimeConfig(),
+        prepare: () => {
+          ensureArtsySetup();
+        },
+        command: (p) => ({
+          // eigen's `yarn start` wraps `react-native start` with a relay watcher
+          // via concurrently; for the demo we run relay once in prepare and
+          // invoke the metro server directly so --port is respected.
+          cmd: `npx react-native start --port ${p}`
+        }),
+        credentials: {
+          envVars: ["SOOTSIM_ARTSY_EMAIL", "SOOTSIM_ARTSY_PASSWORD"],
+          note: "auto-login reuses Artsy\u2019s built-in Maestro launch-arguments hook"
+        }
+      }
+    ];
+  }
+});
+
+// scripts/dev-server-scanner.ts
+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();
+  });
+}
+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));
+}
+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 launchUrl = manifest?.launchAsset?.url;
+    if (launchUrl && !result.patched && !isDirectOneBundleUrl(result.bundleUrl)) {
+      result.bundleUrl = withRuntimeConfig(result.port, launchUrl);
+    }
+    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;
+}
+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);
+  }
+  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
+    );
+  }
+  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 launchUrl = 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, launchUrl),
+            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;
+}
+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);
+  }
+  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 });
+  }
+  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));
+}
+var import_child_process, import_http, import_net, import_util, execP, TIMEOUT_MS, TCP_GATE_MS, FALLBACK_PORTS, cwdByPid, knownNonPatched, knownNonExpo, portCache, NEGATIVE_CACHE_TTL_MS, WEAK_RESULT_CACHE_TTL_MS;
+var init_dev_server_scanner = __esm({
+  "scripts/dev-server-scanner.ts"() {
+    "use strict";
+    import_child_process = require("child_process");
+    import_http = __toESM(require("http"), 1);
+    import_net = __toESM(require("net"), 1);
+    import_util = require("util");
+    init_config();
+    init_native_dev_bundle_url();
+    init_demo_app_registry();
+    execP = (0, import_util.promisify)(import_child_process.exec);
+    TIMEOUT_MS = 250;
+    TCP_GATE_MS = 120;
+    FALLBACK_PORTS = [
+      8081,
+      8082,
+      8083,
+      8084,
+      8085,
+      8086,
+      3e3,
+      3001,
+      19e3
+    ].map((port) => ({ port, pid: 0 }));
+    cwdByPid = /* @__PURE__ */ new Map();
+    knownNonPatched = /* @__PURE__ */ new Set();
+    knownNonExpo = /* @__PURE__ */ new Set();
+    portCache = /* @__PURE__ */ new Map();
+    NEGATIVE_CACHE_TTL_MS = 3e4;
+    WEAK_RESULT_CACHE_TTL_MS = 1500;
+  }
+});
+
+// src/agent-events.ts
+function isAgentEvent(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return typeof v.type === "string" && typeof v.ts === "number";
+}
+function parseAgentEventLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    return isAgentEvent(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+var init_agent_events = __esm({
+  "src/agent-events.ts"() {
+    "use strict";
+  }
+});
+
+// src/agent-prompt.ts
+function cleanPromptText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function encodeAgentPromptEnvelope(input) {
+  const text = cleanPromptText(input.text);
+  if (!text) return "";
+  const displayText = cleanPromptText(input.displayText);
+  const inspectSummary = cleanPromptText(input.inspectSummary);
+  const inspectTrace = cleanPromptText(input.inspectTrace);
+  const needsEnvelope = !!inspectSummary || !!inspectTrace || /[\r\n]/.test(text) || !!displayText && displayText !== text;
+  if (!needsEnvelope) return text;
+  return JSON.stringify({
+    __sootsimAgentPrompt: ENVELOPE_MARKER,
+    text,
+    displayText,
+    inspectSummary,
+    inspectTrace
+  });
+}
+var ENVELOPE_MARKER;
+var init_agent_prompt = __esm({
+  "src/agent-prompt.ts"() {
+    "use strict";
+    ENVELOPE_MARKER = "sootsim-agent-prompt-v1";
+  }
+});
+
+// src/attached-projects.ts
+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");
+}
+function getUserDataDir() {
+  return userDataDir();
+}
+function storeFile() {
+  return import_node_path2.default.join(userDataDir(), "attached-projects.json");
+}
+function cloneEmpty() {
+  return {
+    version: 1,
+    attachedProjects: [],
+    previewAttachments: [],
+    agentSessions: []
+  };
+}
+function loadStore() {
+  const file = storeFile();
+  let raw;
+  try {
+    raw = import_node_fs2.default.readFileSync(file, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return cloneEmpty();
+    throw err;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") throw new Error("not an object");
+    return {
+      version: 1,
+      attachedProjects: Array.isArray(parsed.attachedProjects) ? parsed.attachedProjects : [],
+      previewAttachments: Array.isArray(parsed.previewAttachments) ? parsed.previewAttachments : [],
+      agentSessions: Array.isArray(parsed.agentSessions) ? parsed.agentSessions : []
+    };
+  } catch (err) {
+    const quarantine = `${file}.corrupt-${Date.now()}`;
+    try {
+      import_node_fs2.default.renameSync(file, quarantine);
+      console.warn(
+        `[sootsim] attached-projects.json was unparseable; quarantined to ${quarantine}. original error: ${err.message}`
+      );
+    } catch {
+    }
+    return cloneEmpty();
+  }
+}
+function writeStore(store) {
+  const file = storeFile();
+  import_node_fs2.default.mkdirSync(import_node_path2.default.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
+  const fd = import_node_fs2.default.openSync(tmp, "w", 384);
+  try {
+    import_node_fs2.default.writeFileSync(fd, JSON.stringify(store, null, 2));
+    import_node_fs2.default.fsyncSync(fd);
+  } finally {
+    import_node_fs2.default.closeSync(fd);
+  }
+  import_node_fs2.default.renameSync(tmp, file);
+}
+function mutateStore(fn) {
+  const store = loadStore();
+  fn(store);
+  writeStore(store);
+  return store;
+}
+function projectIdForCwd(cwd) {
+  return (0, import_node_crypto.createHash)("sha256").update(import_node_path2.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 id = projectIdForCwd(cwd);
+  let result;
+  mutateStore((store) => {
+    const existing = store.attachedProjects.find((p) => p.id === id);
+    if (existing) {
+      const merged = {
+        ...existing,
+        ...input,
+        id,
+        cwd,
+        sourceRoots: input.sourceRoots ?? existing.sourceRoots,
+        knownBundleUrls: input.knownBundleUrls ?? existing.knownBundleUrls,
+        pinnedSourceResolutions: input.pinnedSourceResolutions ?? existing.pinnedSourceResolutions,
+        telemetry: input.telemetry ?? existing.telemetry,
+        updatedAt: Date.now(),
+        createdAt: existing.createdAt
+      };
+      const idx = store.attachedProjects.indexOf(existing);
+      store.attachedProjects[idx] = merged;
+      result = merged;
+      return;
+    }
+    const now = Date.now();
+    const created = {
+      id,
+      name: input.name ?? import_node_path2.default.basename(cwd),
+      cwd,
+      repoRoot: input.repoRoot,
+      sourceRoots: input.sourceRoots ?? [cwd],
+      framework: input.framework ?? "unknown",
+      bundleId: input.bundleId,
+      knownBundleUrls: input.knownBundleUrls ?? [],
+      preferredProvider: input.preferredProvider ?? "codex",
+      preferredTransport: input.preferredTransport ?? "tmux",
+      editorOpenCommand: input.editorOpenCommand,
+      moshiWebhookToken: input.moshiWebhookToken,
+      pinnedSourceResolutions: input.pinnedSourceResolutions ?? {},
+      isolateDiscovery: input.isolateDiscovery,
+      git: input.git,
+      telemetry: input.telemetry ?? { lastOpened: 0, runsCompleted: 0 },
+      createdAt: now,
+      updatedAt: now
+    };
+    store.attachedProjects.push(created);
+    result = created;
+  });
+  return result;
+}
+function findProjectById(id) {
+  return loadStore().attachedProjects.find((p) => p.id === id) ?? null;
+}
+function listProjects() {
+  return loadStore().attachedProjects;
+}
+function recordTurnTelemetry(projectId, input = {}) {
+  mutateStore((store) => {
+    const project = store.attachedProjects.find((p) => p.id === projectId);
+    if (!project) return;
+    const ts = input.ts ?? Date.now();
+    project.telemetry.runsCompleted = (project.telemetry.runsCompleted ?? 0) + 1;
+    if (typeof input.usd === "number" && Number.isFinite(input.usd) && input.usd >= 0) {
+      const history = project.telemetry.costHistory ?? [];
+      const cutoff = ts - COST_HISTORY_MAX_AGE_MS;
+      const trimmed = history.filter((e) => e.ts >= cutoff);
+      trimmed.push({ ts, usd: input.usd });
+      project.telemetry.costHistory = trimmed;
+    }
+    project.updatedAt = ts;
+  });
+}
+function deleteProject(id) {
+  mutateStore((store) => {
+    store.attachedProjects = store.attachedProjects.filter((p) => p.id !== id);
+    store.agentSessions = store.agentSessions.filter((s) => s.projectId !== id);
+    store.previewAttachments = store.previewAttachments.filter(
+      (pa) => pa.projectId !== id
+    );
+  });
+}
+function upsertSession(input) {
+  let result;
+  mutateStore((store) => {
+    if (input.id) {
+      const existing = store.agentSessions.find((s) => s.id === input.id);
+      if (existing) {
+        const merged = {
+          ...existing,
+          ...input,
+          lastSeenAt: Date.now()
+        };
+        const idx = store.agentSessions.indexOf(existing);
+        store.agentSessions[idx] = merged;
+        result = merged;
+        return;
+      }
+    }
+    const project = store.attachedProjects.find((p) => p.id === input.projectId);
+    if (!project) {
+      throw new Error(`upsertSession: no AttachedProject with id=${input.projectId}`);
+    }
+    const now = Date.now();
+    const created = {
+      id: input.id ?? newSessionId(),
+      projectId: input.projectId,
+      provider: input.provider,
+      transport: input.transport ?? project.preferredTransport,
+      cwd: input.cwd ?? project.cwd,
+      claudeSessionUuid: input.claudeSessionUuid,
+      tmuxSessionName: input.tmuxSessionName,
+      wrapperPid: input.wrapperPid,
+      status: input.status ?? "idle",
+      needsAttention: input.needsAttention ?? false,
+      lastPrompt: input.lastPrompt,
+      lastSummary: input.lastSummary,
+      lastTurnFiles: input.lastTurnFiles,
+      currentlyEditing: input.currentlyEditing,
+      lastSeenAt: now,
+      createdAt: now
+    };
+    store.agentSessions.push(created);
+    result = created;
+  });
+  return result;
+}
+function findSessionById(id) {
+  return loadStore().agentSessions.find((s) => s.id === id) ?? null;
+}
+function listSessions(projectId) {
+  const all = loadStore().agentSessions;
+  return projectId ? all.filter((s) => s.projectId === projectId) : all;
+}
+function updateSessionStatus(id, patch) {
+  mutateStore((store) => {
+    const existing = store.agentSessions.find((s) => s.id === id);
+    if (!existing) return;
+    const idx = store.agentSessions.indexOf(existing);
+    store.agentSessions[idx] = {
+      ...existing,
+      ...patch,
+      id: existing.id,
+      projectId: existing.projectId,
+      createdAt: existing.createdAt,
+      lastSeenAt: Date.now()
+    };
+  });
+}
+async function seedFromDemoAppRegistry() {
+  const existing = loadStore().attachedProjects;
+  if (existing.length > 0) return;
+  let APPS2;
+  try {
+    const mod = await import("sootsim/scripts/demo-app-registry");
+    APPS2 = mod.APPS;
+  } catch (err) {
+    console.warn(
+      "[sootsim] seedFromDemoAppRegistry: could not load demo registry:",
+      err.message
+    );
+    return;
+  }
+  if (!Array.isArray(APPS2)) return;
+  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);
+      const id = projectIdForCwd(cwd);
+      if (store.attachedProjects.some((p) => p.id === id)) continue;
+      const now = Date.now();
+      store.attachedProjects.push({
+        id,
+        name: app.label,
+        cwd,
+        sourceRoots: [cwd],
+        framework: app.framework,
+        knownBundleUrls: [`http://localhost:${app.preferredPort}/index.bundle`],
+        preferredProvider: "codex",
+        preferredTransport: "tmux",
+        pinnedSourceResolutions: {},
+        telemetry: { lastOpened: 0, runsCompleted: 0 },
+        createdAt: now,
+        updatedAt: now
+      });
+    }
+  });
+}
+var import_node_crypto, import_node_fs2, import_node_os2, import_node_path2, overrideDir, COST_HISTORY_MAX_AGE_MS;
+var init_attached_projects = __esm({
+  "src/attached-projects.ts"() {
+    "use strict";
+    import_node_crypto = require("node:crypto");
+    import_node_fs2 = __toESM(require("node:fs"), 1);
+    import_node_os2 = __toESM(require("node:os"), 1);
+    import_node_path2 = __toESM(require("node:path"), 1);
+    overrideDir = null;
+    COST_HISTORY_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
+  }
+});
+
+// src/agent-sessions.ts
+function sessionDir(sessionId) {
+  return import_node_path3.default.join(getUserDataDir(), "sessions", sessionId);
+}
+function promptFifoPath(sessionId) {
+  return import_node_path3.default.join(sessionDir(sessionId), "prompt.in");
+}
+function eventsFifoPath(sessionId) {
+  return import_node_path3.default.join(sessionDir(sessionId), "events.out");
+}
+function transcriptPath(sessionId) {
+  return import_node_path3.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
+}
+function pidIsAlive(pid, sessionId) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+  } catch {
+    return false;
+  }
+  if (sessionId) {
+    if (!import_node_fs3.default.existsSync(sessionDir(sessionId))) return false;
+  }
+  return true;
+}
+function resolveSootsimInvocation() {
+  if (process.env.SOOTSIM_BIN) {
+    return { cmd: process.env.SOOTSIM_BIN, prefixArgs: [] };
+  }
+  if (process.versions.electron) {
+    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}`)
+      ];
+      for (const c of candidates) {
+        if (import_node_fs3.default.existsSync(c)) return { cmd: c, prefixArgs: [] };
+      }
+    }
+  }
+  const workspace = tryWorkspaceSootsim();
+  if (workspace) return workspace;
+  const argv0 = process.argv[0];
+  const argv1 = process.argv[1];
+  if (argv1 && /\.(ts|tsx|mjs|cjs|js)$/.test(argv1)) {
+    return { cmd: argv0, prefixArgs: [argv1] };
+  }
+  if (!argv1 || argv1.includes("/.bin/")) {
+    throw new Error(
+      "sootsim CLI not found. set SOOTSIM_BIN to the path of the sootsim binary, or build the workspace CLI via `bun run --cwd packages/sootsim build:cli`."
+    );
+  }
+  return { cmd: argv0, prefixArgs: [] };
+}
+function tryWorkspaceSootsim() {
+  try {
+    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)) {
+      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;
+          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).`
+            );
+          }
+        }
+      } catch {
+      }
+      return { cmd: process.execPath, prefixArgs: [distBin] };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function resolveSootsimPackageDir() {
+  try {
+    const resolved = require.resolve("sootsim/package.json");
+    return import_node_path3.default.dirname(resolved);
+  } catch {
+  }
+  const here = fileFromImportMeta();
+  if (!here) return null;
+  let cur = import_node_path3.default.dirname(here);
+  for (let i = 0; i < 8; i++) {
+    const pkg = import_node_path3.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 (parsed.name === "sootsim") return cur;
+      }
+    } catch {
+    }
+    const parent = import_node_path3.default.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return null;
+}
+function fileFromImportMeta() {
+  try {
+    const url = __sootsim_import_meta_url;
+    if (!url || !url.startsWith("file://")) return null;
+    return decodeURIComponent(url.slice("file://".length));
+  } catch {
+    return null;
+  }
+}
+async function withStartLock(projectId, provider, fn) {
+  const lockDir = import_node_path3.default.join(getUserDataDir(), "locks");
+  import_node_fs3.default.mkdirSync(lockDir, { recursive: true });
+  try {
+    import_node_fs3.default.chmodSync(lockDir, 448);
+  } catch {
+  }
+  const lockPath = import_node_path3.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(
+        lockPath,
+        import_node_fs3.constants.O_WRONLY | import_node_fs3.constants.O_CREAT | import_node_fs3.constants.O_EXCL,
+        384
+      );
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+      try {
+        const stale = Number(import_node_fs3.default.readFileSync(lockPath, "utf8").trim());
+        if (stale && !isProcessAlive(stale)) {
+          import_node_fs3.default.unlinkSync(lockPath);
+          continue;
+        }
+      } catch {
+      }
+      if (Date.now() > deadline) {
+        throw new Error(
+          `another start is in progress for project=${projectId} provider=${provider} (lock: ${lockPath})`
+        );
+      }
+      await new Promise((r) => setTimeout(r, 50));
+    }
+  }
+  try {
+    import_node_fs3.default.writeFileSync(fd, String(process.pid));
+    return await fn();
+  } finally {
+    try {
+      import_node_fs3.default.closeSync(fd);
+    } catch {
+    }
+    try {
+      import_node_fs3.default.unlinkSync(lockPath);
+    } catch {
+    }
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function mkfifoSync(p) {
+  const parent = import_node_path3.default.dirname(p);
+  import_node_fs3.default.mkdirSync(parent, { recursive: true });
+  try {
+    import_node_fs3.default.chmodSync(parent, 448);
+  } catch {
+  }
+  if (import_node_fs3.default.existsSync(p)) {
+    try {
+      const stat = import_node_fs3.default.statSync(p);
+      if (stat.isFIFO()) {
+        try {
+          import_node_fs3.default.chmodSync(p, 384);
+        } catch {
+        }
+        return;
+      }
+      import_node_fs3.default.unlinkSync(p);
+    } catch {
+      import_node_fs3.default.unlinkSync(p);
+    }
+  }
+  const result = (0, import_node_child_process.spawnSync)("mkfifo", ["-m", "600", p]);
+  if (result.status !== 0) {
+    throw new Error(
+      `mkfifo(${p}) failed: ${result.stderr?.toString().trim() || "unknown error"}`
+    );
+  }
+}
+async function startSession(opts) {
+  const project = findProjectById(opts.projectId);
+  if (!project) {
+    throw new AgentSessionError("NO_PROJECT", `no project with id=${opts.projectId}`);
+  }
+  const provider = opts.provider || project.preferredProvider || "codex";
+  return withStartLock(project.id, provider, async () => {
+    const existingLive = listSessions(project.id).find(
+      (s) => s.provider === provider && s.status !== "ended" && pidIsAlive(s.wrapperPid, s.id)
+    );
+    if (existingLive) {
+      throw new AgentSessionError(
+        "ALREADY_RUNNING",
+        `session already running for project=${project.id} provider=${provider} (session ${existingLive.id}, pid ${existingLive.wrapperPid}). end it first with \`sootsim agent end <sessionId>\`.`
+      );
+    }
+    const claudeSessionUuid = provider === "claude" ? (0, import_node_crypto2.randomUUID)() : void 0;
+    const session = upsertSession({
+      projectId: project.id,
+      provider,
+      transport: "pty",
+      cwd: project.cwd,
+      status: "idle",
+      claudeSessionUuid
+    });
+    const promptIn = promptFifoPath(session.id);
+    const eventsOut = eventsFifoPath(session.id);
+    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 });
+    try {
+      import_node_fs3.default.chmodSync(transcriptDir, 448);
+    } catch {
+    }
+    const { cmd, prefixArgs } = resolveSootsimInvocation();
+    const wrapperArgs = [
+      ...prefixArgs,
+      "agent-wrapper",
+      "--session-id",
+      session.id,
+      "--project-id",
+      project.id,
+      "--provider",
+      provider,
+      "--cwd",
+      project.cwd,
+      "--prompt-in",
+      promptIn,
+      "--events-out",
+      eventsOut,
+      "--transcript",
+      transcript
+    ];
+    if (opts.codexBin) wrapperArgs.push("--codex-bin", opts.codexBin);
+    if (opts.claudeBin) wrapperArgs.push("--claude-bin", opts.claudeBin);
+    if (claudeSessionUuid) {
+      wrapperArgs.push("--claude-session-uuid", claudeSessionUuid);
+    }
+    const child = (0, import_node_child_process.spawn)(cmd, wrapperArgs, {
+      detached: true,
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        SOOTSIM_USER_DATA_DIR: getUserDataDir()
+      }
+    });
+    child.unref();
+    const readyTimeout = opts.readyTimeoutMs ?? 6e3;
+    const boot = await waitForFirstEvent(
+      eventsOut,
+      (e) => e.type === "ready" || e.type === "error",
+      readyTimeout
+    );
+    if (!boot || boot.type === "error") {
+      if (child.pid) {
+        try {
+          process.kill(child.pid, "SIGTERM");
+        } catch {
+        }
+      }
+      try {
+        import_node_fs3.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
+      } catch {
+      }
+      updateSessionStatus(session.id, { status: "ended" });
+      const reason = boot && boot.type === "error" ? boot.message : `no ready event within ${readyTimeout}ms`;
+      throw new AgentSessionError("WRAPPER_FAILED", reason);
+    }
+    updateSessionStatus(session.id, {
+      wrapperPid: child.pid,
+      status: "idle"
+    });
+    const updated = findSessionById(session.id);
+    return { session: updated, wrapperPid: child.pid };
+  });
+}
+async function sendPrompt(sessionId, prompt) {
+  const session = findSessionById(sessionId);
+  if (!session) {
+    throw new AgentSessionError("NO_SESSION", `no session with id=${sessionId}`);
+  }
+  if (!pidIsAlive(session.wrapperPid, sessionId)) {
+    updateSessionStatus(sessionId, { status: "ended" });
+    throw new AgentSessionError(
+      "NOT_ALIVE",
+      `session wrapper is not alive (pid=${session.wrapperPid}). start a new session.`
+    );
+  }
+  const fifo = promptFifoPath(sessionId);
+  if (!import_node_fs3.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);
+  try {
+    const wireText = encodeAgentPromptEnvelope(prompt);
+    if (!wireText) {
+      throw new AgentSessionError("EMPTY_PROMPT", "prompt text is empty");
+    }
+    import_node_fs3.default.writeSync(fd, wireText + "\n");
+  } finally {
+    import_node_fs3.default.closeSync(fd);
+  }
+  updateSessionStatus(sessionId, {
+    lastPrompt: prompt.displayText ?? prompt.text,
+    status: "working"
+  });
+}
+async function endSession(sessionId) {
+  const session = findSessionById(sessionId);
+  if (!session) {
+    throw new AgentSessionError("NO_SESSION", `no session with id=${sessionId}`);
+  }
+  if (pidIsAlive(session.wrapperPid, sessionId)) {
+    try {
+      process.kill(session.wrapperPid, "SIGTERM");
+    } catch {
+    }
+  }
+  const dir = sessionDir(sessionId);
+  const base = getUserDataDir();
+  if (dir.startsWith(base)) {
+    try {
+      import_node_fs3.default.rmSync(dir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  updateSessionStatus(sessionId, { status: "ended", wrapperPid: void 0 });
+}
+function subscribeEvents(sessionId, onEvent) {
+  const fifo = eventsFifoPath(sessionId);
+  if (!import_node_fs3.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 rl = import_node_readline.default.createInterface({ input: stream, crlfDelay: Infinity });
+  rl.on("line", (line) => {
+    const event = parseAgentEventLine(line);
+    if (event) onEvent(event);
+  });
+  let closed = false;
+  return () => {
+    if (closed) return;
+    closed = true;
+    try {
+      rl.close();
+    } catch {
+    }
+    try {
+      stream.destroy();
+    } catch {
+    }
+  };
+}
+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 buf = Buffer.alloc(8192);
+  let leftover = "";
+  const deadline = Date.now() + timeoutMs;
+  try {
+    while (Date.now() < deadline) {
+      let n = 0;
+      try {
+        n = import_node_fs3.default.readSync(fd, buf, 0, buf.length, null);
+      } catch (err) {
+        if (err.code !== "EAGAIN") throw err;
+        n = 0;
+      }
+      if (n > 0) {
+        leftover += buf.subarray(0, n).toString("utf8");
+        let idx;
+        while ((idx = leftover.indexOf("\n")) >= 0) {
+          const line = leftover.slice(0, idx);
+          leftover = leftover.slice(idx + 1);
+          const event = parseAgentEventLine(line);
+          if (event && predicate(event)) return event;
+        }
+      } else {
+        await new Promise((r) => setTimeout(r, 30));
+      }
+    }
+    return null;
+  } finally {
+    import_node_fs3.default.closeSync(fd);
+  }
+}
+var import_node_child_process, import_node_crypto2, import_node_fs3, import_node_path3, import_node_readline, AgentSessionError;
+var init_agent_sessions = __esm({
+  "src/agent-sessions.ts"() {
+    "use strict";
+    import_node_child_process = require("node:child_process");
+    import_node_crypto2 = require("node:crypto");
+    import_node_fs3 = __toESM(require("node:fs"), 1);
+    import_node_path3 = __toESM(require("node:path"), 1);
+    import_node_readline = __toESM(require("node:readline"), 1);
+    init_agent_events();
+    init_agent_prompt();
+    init_attached_projects();
+    AgentSessionError = class extends Error {
+      code;
+      constructor(code, message) {
+        super(message);
+        this.code = code;
+      }
+    };
+  }
+});
+
+// src/host/agent-host.ts
+function defaultExcludePorts() {
+  return [
+    Number(process.env.VITE_PORT_WEB || process.env.PORT || 3e3),
+    Number(process.env.VITE_PORT_ZERO || 7849),
+    Number(process.env.VITE_PORT_POSTGRES || 7432),
+    Number(process.env.VITE_PORT_R2 || 9500)
+  ].filter((p) => Number.isFinite(p) && p > 0);
+}
+function mapFrameworkToProjectFramework(fw) {
+  if (fw === "expo") return "expo";
+  if (fw === "one" || fw === "vxrn") return "one";
+  return "unknown";
+}
+var import_node_fs4, import_node_path4, WS_OPEN, AgentHost;
+var init_agent_host = __esm({
+  "src/host/agent-host.ts"() {
+    "use strict";
+    import_node_fs4 = __toESM(require("node:fs"), 1);
+    import_node_path4 = __toESM(require("node:path"), 1);
+    init_dev_server_scanner();
+    init_agent_sessions();
+    init_attached_projects();
+    WS_OPEN = 1;
+    AgentHost = class {
+      // live fan-out, keyed by sessionId. refcount tracks how many sockets have
+      // subscribed; the FIFO reader stays open as long as refcount > 0.
+      subscriptions = /* @__PURE__ */ new Map();
+      // per-socket subscription set so ws.close can clean up without scanning
+      // every session.
+      sessionsBySocket = /* @__PURE__ */ new Map();
+      // every connected socket (regardless of role) — gets session-status
+      // pushes so a CLI `sootsim agent sessions --watch` can react to state
+      // changes driven by another client.
+      allSockets = /* @__PURE__ */ new Set();
+      // agent wrappers also emit prompt-received from the FIFO reader, but the
+      // shell/daemon already knows the user-facing display text when send-prompt
+      // is accepted. emit the friendly prompt immediately and suppress the raw
+      // wrapper echoes that follow a moment later.
+      pendingPromptEchoes = /* @__PURE__ */ new Map();
+      // accepted prompts serialize inside the wrapper, so a second send while the
+      // session is already working becomes queued follow-up work. keep a small
+      // in-memory count so session status stays `working` until that backlog
+      // truly drains.
+      pendingTurns = /* @__PURE__ */ new Map();
+      opts;
+      constructor(opts = {}) {
+        this.opts = opts;
+      }
+      registerSocket(ws) {
+        this.allSockets.add(ws);
+      }
+      unregisterSocket(ws) {
+        const sessions = this.sessionsBySocket.get(ws);
+        if (sessions) {
+          for (const sessionId of sessions) {
+            this.decrementSubscription(sessionId);
+          }
+          this.sessionsBySocket.delete(ws);
+        }
+        this.allSockets.delete(ws);
+      }
+      /** handle an agent:* message. returns true iff the message was recognized
+       *  as an agent message (so the caller knows to stop dispatching). */
+      async handleMessage(ws, msg) {
+        const type = msg?.type;
+        if (typeof type !== "string" || !type.startsWith("agent:")) return false;
+        const id = msg.id;
+        try {
+          const result = await this.dispatch(ws, type, msg);
+          this.respond(ws, id, result);
+        } catch (err) {
+          if (err instanceof AgentSessionError) {
+            this.respondError(ws, id, err.message, err.code);
+          } else {
+            this.respondError(ws, id, err instanceof Error ? err.message : String(err));
+          }
+        }
+        return true;
+      }
+      /** run once on daemon boot. idempotent — `seedFromDemoAppRegistry` no-ops
+       *  when the store already has projects. */
+      async seedOnBoot() {
+        try {
+          await seedFromDemoAppRegistry();
+        } catch (err) {
+          process.stderr.write(
+            `[sootsim-agent] seedFromDemoAppRegistry failed: ${err instanceof Error ? err.message : String(err)}
+`
+          );
+        }
+      }
+      /** terminate every subscription and drop every socket reference. called
+       *  by the bridge host during shutdown. */
+      close() {
+        for (const sub of this.subscriptions.values()) {
+          try {
+            sub.unsubscribe();
+          } catch {
+          }
+        }
+        this.subscriptions.clear();
+        this.sessionsBySocket.clear();
+        this.allSockets.clear();
+      }
+      // --- dispatch ---
+      async dispatch(ws, type, msg) {
+        switch (type) {
+          case "agent:list-projects":
+            return listProjects();
+          case "agent:upsert-project":
+            return upsertProject(msg.input ?? {});
+          case "agent:delete-project":
+            deleteProject(String(msg.projectId));
+            return { ok: true };
+          case "agent:auto-attach-for-url":
+            return this.autoAttachForUrl(msg.input ?? {});
+          case "agent:list-sessions":
+            return listSessions(msg.projectId ? String(msg.projectId) : void 0);
+          case "agent:start-session":
+            return this.doStartSession(msg.input ?? {});
+          case "agent:send-prompt": {
+            const sessionId = String(msg.sessionId);
+            const session = findSessionById(sessionId);
+            if (!session) {
+              throw new AgentSessionError("NO_SESSION", `no session: ${sessionId}`);
+            }
+            const prompt = this.normalizePromptEnvelope(msg);
+            await sendPrompt(sessionId, prompt);
+            return this.notePromptAccepted(sessionId, prompt, session.status === "working");
+          }
+          case "agent:end-session":
+            this.dropSessionFanout(String(msg.sessionId));
+            await endSession(String(msg.sessionId));
+            const ended = findSessionById(String(msg.sessionId));
+            if (ended) {
+              this.broadcastSessionStatus(ended);
+            }
+            return { ok: true };
+          case "agent:get-transcript":
+            return this.getTranscript(String(msg.sessionId));
+          case "agent:get-paths":
+            return this.getPaths();
+          case "agent:subscribe-events":
+            return this.subscribeSocket(ws, String(msg.sessionId));
+          case "agent:unsubscribe-events":
+            return this.unsubscribeSocket(ws, String(msg.sessionId));
+          default:
+            throw new AgentSessionError("UNKNOWN_AGENT_MSG", `unknown agent message: ${type}`);
+        }
+      }
+      // --- operation impls ---
+      async doStartSession(input) {
+        const project = findProjectById(input.projectId);
+        if (!project) {
+          throw new AgentSessionError("NO_PROJECT", `no project: ${input.projectId}`);
+        }
+        const result = await startSession(input);
+        this.broadcastSessionStatus(result.session);
+        return result;
+      }
+      async autoAttachForUrl(input) {
+        const bundleUrl = input.bundleUrl ?? "";
+        const targetPort = (() => {
+          try {
+            return new URL(bundleUrl).port || null;
+          } catch {
+            return null;
+          }
+        })();
+        if (!targetPort) return { project: null };
+        const excludePorts = this.opts.getExcludePorts?.() ?? defaultExcludePorts();
+        const servers = await scanDevServers({ excludePorts });
+        const match = servers.find((s) => String(s.port) === targetPort);
+        if (!match || !match.cwd) return { project: null };
+        const existing = listProjects().find((p) => p.cwd === match.cwd) ?? null;
+        const knownBundleUrls = Array.from(
+          /* @__PURE__ */ new Set([...existing?.knownBundleUrls ?? [], match.bundleUrl, bundleUrl])
+        );
+        const project = upsertProject({
+          cwd: match.cwd,
+          name: match.projectName ?? import_node_path4.default.basename(match.cwd),
+          preferredProvider: input.provider ?? existing?.preferredProvider,
+          sourceRoots: existing?.sourceRoots ?? [match.cwd],
+          knownBundleUrls,
+          framework: existing?.framework ?? mapFrameworkToProjectFramework(match.framework),
+          bundleId: match.bundleId ?? existing?.bundleId
+        });
+        return { project };
+      }
+      getTranscript(sessionId) {
+        const p = transcriptPath(sessionId);
+        if (!import_node_fs4.default.existsSync(p)) {
+          return { error: "transcript not found", code: "NO_TRANSCRIPT" };
+        }
+        return import_node_fs4.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")
+        };
+      }
+      // --- subscription management ---
+      subscribeSocket(ws, sessionId) {
+        let sockets = this.sessionsBySocket.get(ws);
+        if (!sockets) {
+          sockets = /* @__PURE__ */ new Set();
+          this.sessionsBySocket.set(ws, sockets);
+        }
+        if (sockets.has(sessionId)) {
+          return { ok: true, refCount: this.subscriptions.get(sessionId)?.refCount ?? 1 };
+        }
+        sockets.add(sessionId);
+        const existing = this.subscriptions.get(sessionId);
+        if (existing) {
+          existing.refCount++;
+          return { ok: true, refCount: existing.refCount };
+        }
+        const unsubscribe = subscribeEvents(sessionId, (event) => {
+          const coalesced = this.coalescePromptEcho(sessionId, event);
+          if (coalesced) {
+            this.applySessionEvent(sessionId, coalesced);
+            this.fanOutEvent(sessionId, coalesced);
+          }
+          if (event.type === "turn-completed") {
+            const session = findSessionById(sessionId);
+            if (session) {
+              try {
+                recordTurnTelemetry(session.projectId, {
+                  usd: event.costUsd,
+                  ts: event.ts
+                });
+              } catch (err) {
+                process.stderr.write(
+                  `[sootsim-agent] recordTurnTelemetry failed: ${err instanceof Error ? err.message : String(err)}
+`
+                );
+              }
+            }
+          }
+        });
+        this.subscriptions.set(sessionId, { unsubscribe, refCount: 1 });
+        return { ok: true, refCount: 1 };
+      }
+      unsubscribeSocket(ws, sessionId) {
+        const sockets = this.sessionsBySocket.get(ws);
+        if (!sockets || !sockets.has(sessionId)) return { ok: true, refCount: 0 };
+        sockets.delete(sessionId);
+        return this.decrementSubscription(sessionId);
+      }
+      decrementSubscription(sessionId) {
+        const existing = this.subscriptions.get(sessionId);
+        if (!existing) return { ok: true, refCount: 0 };
+        existing.refCount--;
+        if (existing.refCount <= 0) {
+          try {
+            existing.unsubscribe();
+          } catch {
+          }
+          this.subscriptions.delete(sessionId);
+          return { ok: true, refCount: 0 };
+        }
+        return { ok: true, refCount: existing.refCount };
+      }
+      /** end-session tears the FIFO down, so drop our reader before it
+       *  disappears regardless of remaining subscriber refcount. */
+      dropSessionFanout(sessionId) {
+        const existing = this.subscriptions.get(sessionId);
+        if (existing) {
+          try {
+            existing.unsubscribe();
+          } catch {
+          }
+          this.subscriptions.delete(sessionId);
+        }
+        for (const sockets of this.sessionsBySocket.values()) {
+          sockets.delete(sessionId);
+        }
+        this.clearPromptTracking(sessionId);
+      }
+      // --- wire pushes + responses ---
+      normalizePromptEnvelope(msg) {
+        if (msg?.prompt && typeof msg.prompt === "object") {
+          const prompt = msg.prompt;
+          return {
+            text: String(prompt.text ?? ""),
+            ...typeof prompt.displayText === "string" ? { displayText: prompt.displayText } : {},
+            ...typeof prompt.inspectSummary === "string" ? { inspectSummary: prompt.inspectSummary } : {},
+            ...typeof prompt.inspectTrace === "string" ? { inspectTrace: prompt.inspectTrace } : {}
+          };
+        }
+        return {
+          text: String(msg?.text ?? ""),
+          ...typeof msg?.displayText === "string" ? { displayText: msg.displayText } : {},
+          ...typeof msg?.inspectSummary === "string" ? { inspectSummary: msg.inspectSummary } : {},
+          ...typeof msg?.inspectTrace === "string" ? { inspectTrace: msg.inspectTrace } : {}
+        };
+      }
+      notePromptAccepted(sessionId, prompt, assumeQueued) {
+        const now = Date.now();
+        const echoes = this.pendingPromptEchoes.get(sessionId) ?? [];
+        echoes.push({ sentAt: now });
+        this.pendingPromptEchoes.set(sessionId, echoes);
+        const pendingTurns = Math.max(this.pendingTurns.get(sessionId) ?? 0, assumeQueued ? 1 : 0) + 1;
+        this.pendingTurns.set(sessionId, pendingTurns);
+        const promptText = prompt.displayText ?? prompt.text;
+        this.patchSession(sessionId, {
+          lastPrompt: promptText,
+          status: "working",
+          needsAttention: false
+        });
+        this.fanOutEvent(sessionId, {
+          type: "prompt-received",
+          text: promptText,
+          ...prompt.inspectSummary ? { inspectSummary: prompt.inspectSummary } : {},
+          ...prompt.inspectTrace ? { inspectTrace: prompt.inspectTrace } : {},
+          ts: now
+        });
+        return {
+          ok: true,
+          queued: pendingTurns > 1,
+          pendingTurns,
+          queueDepth: Math.max(0, pendingTurns - 1)
+        };
+      }
+      applySessionEvent(sessionId, event) {
+        switch (event.type) {
+          case "prompt-received":
+          case "turn-started":
+            this.patchSession(sessionId, {
+              status: "working",
+              needsAttention: false
+            });
+            return;
+          case "turn-completed": {
+            const pendingTurns = this.consumeSettledTurn(sessionId);
+            this.patchSession(sessionId, {
+              status: pendingTurns > 0 ? "working" : "idle",
+              needsAttention: false,
+              lastTurnFiles: event.filesTouched,
+              currentlyEditing: void 0
+            });
+            return;
+          }
+          case "approval-needed":
+            this.patchSession(sessionId, {
+              status: "needs-attention",
+              needsAttention: true
+            });
+            return;
+          case "error": {
+            const pendingTurns = this.consumeSettledTurn(sessionId);
+            this.patchSession(sessionId, {
+              status: pendingTurns > 0 ? "working" : "needs-attention",
+              needsAttention: pendingTurns <= 0,
+              currentlyEditing: void 0
+            });
+            return;
+          }
+          case "exited":
+            this.clearPromptTracking(sessionId);
+            this.patchSession(sessionId, {
+              status: "ended",
+              needsAttention: false,
+              wrapperPid: void 0,
+              currentlyEditing: void 0
+            });
+            return;
+          case "ready":
+          case "turn-reasoning":
+          case "turn-message":
+          case "turn-plan":
+          case "tool-call":
+          case "file-edited":
+          case "file-diff-delta":
+            return;
+        }
+      }
+      patchSession(sessionId, patch) {
+        updateSessionStatus(sessionId, patch);
+        const updated = findSessionById(sessionId);
+        if (updated) {
+          this.broadcastSessionStatus(updated);
+        }
+      }
+      coalescePromptEcho(sessionId, event) {
+        if (event.type !== "prompt-received") return event;
+        const pending = this.pendingPromptEchoes.get(sessionId);
+        if (!pending || pending.length === 0) return event;
+        while (pending.length > 0 && Date.now() - pending[0].sentAt > 15e3) {
+          pending.shift();
+        }
+        if (pending.length === 0) {
+          this.pendingPromptEchoes.delete(sessionId);
+          return event;
+        }
+        pending.shift();
+        if (pending.length === 0) {
+          this.pendingPromptEchoes.delete(sessionId);
+        } else {
+          this.pendingPromptEchoes.set(sessionId, pending);
+        }
+        return null;
+      }
+      consumeSettledTurn(sessionId) {
+        const pendingTurns = Math.max(0, (this.pendingTurns.get(sessionId) ?? 1) - 1);
+        if (pendingTurns > 0) {
+          this.pendingTurns.set(sessionId, pendingTurns);
+        } else {
+          this.pendingTurns.delete(sessionId);
+        }
+        return pendingTurns;
+      }
+      clearPromptTracking(sessionId) {
+        this.pendingPromptEchoes.delete(sessionId);
+        this.pendingTurns.delete(sessionId);
+      }
+      fanOutEvent(sessionId, event) {
+        const payload = JSON.stringify({ type: "agent:event", sessionId, event });
+        for (const [ws, sessions] of this.sessionsBySocket) {
+          if (!sessions.has(sessionId)) continue;
+          if (ws.readyState !== WS_OPEN) continue;
+          try {
+            ws.send(payload);
+          } catch {
+          }
+        }
+      }
+      broadcastSessionStatus(session) {
+        const payload = JSON.stringify({ type: "agent:session-status", session });
+        for (const ws of this.allSockets) {
+          if (ws.readyState !== WS_OPEN) continue;
+          try {
+            ws.send(payload);
+          } catch {
+          }
+        }
+      }
+      respond(ws, id, result) {
+        if (ws.readyState !== WS_OPEN) return;
+        try {
+          ws.send(JSON.stringify({ id, result }));
+        } catch {
+        }
+      }
+      respondError(ws, id, error, code) {
+        if (ws.readyState !== WS_OPEN) return;
+        try {
+          ws.send(JSON.stringify({ id, error, ...code ? { code } : {} }));
+        } catch {
+        }
+      }
+    };
+  }
+});
+
+// src/host/bridge-host.ts
+var bridge_host_exports = {};
+__export(bridge_host_exports, {
+  SootSimBridgeHost: () => SootSimBridgeHost
+});
+function shouldAcquireLease(msg) {
+  if (!msg || typeof msg.type !== "string") return false;
+  if (msg.acquireLock === true) return true;
+  if (msg.readOnly === true) return false;
+  return WRITE_COMMAND_TYPES.has(msg.type);
+}
+var import_child_process2, import_fs2, import_http2, import_path2, import_ws, WRITE_COMMAND_TYPES, DAEMON_HEARTBEAT_INTERVAL_MS, HTTP_MIME_TYPES, SootSimBridgeHost;
+var init_bridge_host = __esm({
+  "src/host/bridge-host.ts"() {
+    "use strict";
+    import_child_process2 = require("child_process");
+    import_fs2 = __toESM(require("fs"), 1);
+    import_http2 = require("http");
+    import_path2 = __toESM(require("path"), 1);
+    import_ws = require("ws");
+    init_bridge_constants();
+    init_home_paths();
+    init_agent_host();
+    WRITE_COMMAND_TYPES = /* @__PURE__ */ new Set(["tap", "keyboard", "close"]);
+    DAEMON_HEARTBEAT_INTERVAL_MS = 5e3;
+    HTTP_MIME_TYPES = {
+      ".html": "text/html; charset=utf-8",
+      ".js": "application/javascript",
+      ".cjs": "application/javascript",
+      ".mjs": "application/javascript",
+      ".css": "text/css; charset=utf-8",
+      ".json": "application/json; charset=utf-8",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".svg": "image/svg+xml",
+      ".webp": "image/webp",
+      ".avif": "image/avif",
+      ".ico": "image/x-icon",
+      ".wasm": "application/wasm",
+      ".ttf": "font/ttf",
+      ".otf": "font/otf",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2",
+      ".map": "application/json",
+      ".txt": "text/plain; charset=utf-8"
+    };
+    SootSimBridgeHost = class _SootSimBridgeHost {
+      port;
+      openUrlHandler;
+      httpServer = null;
+      wss = null;
+      nextCommandId = 1;
+      nextBrowserId = 1;
+      browsers = /* @__PURE__ */ new Map();
+      primaryBrowserId = null;
+      pendingCommands = /* @__PURE__ */ new Map();
+      cliBySentId = /* @__PURE__ */ new Map();
+      cliBrowserBySocket = /* @__PURE__ */ new Map();
+      cliLastCommandAt = /* @__PURE__ */ new Map();
+      cliSessionKeyBySocket = /* @__PURE__ */ new Map();
+      cliLabelBySocket = /* @__PURE__ */ new Map();
+      restorableBrowsers = /* @__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;
+      static BROWSER_RECONNECT_TTL_MS = 3e4;
+      preferredPort;
+      portFallbackCount;
+      shouldWriteLockfile;
+      effectivePort = 0;
+      startedAt = 0;
+      heartbeatTimer = null;
+      activeRuntimeVersion = null;
+      activeRuntimeDirPath = null;
+      constructor(opts = {}) {
+        this.preferredPort = opts.port || DEFAULT_SOOTSIM_BRIDGE_PORT;
+        this.port = this.preferredPort;
+        this.shouldWriteLockfile = opts.writeLockfile === true;
+        const defaultFallback = this.shouldWriteLockfile ? 1 : 10;
+        this.portFallbackCount = Math.max(1, opts.portFallbackCount ?? defaultFallback);
+        this.openUrlHandler = opts.openUrl;
+        this.agentHost = new AgentHost({ getExcludePorts: opts.agentScanExcludes });
+      }
+      /** expose the agent host so tests and embedders can inspect state or
+       *  inject behavior. not part of the public WS protocol. */
+      getAgentHost() {
+        return this.agentHost;
+      }
+      /** synchronous wrapper around startAsync for callers that don't care
+       *  about port fallback outcomes. returns immediately; actual binding
+       *  happens on the event loop. callers that need to know the bound port
+       *  should await startAsync() instead. */
+      start(options) {
+        void this.startAsync(options);
+      }
+      async startAsync(options) {
+        if (this.httpServer || this.wss) return this.effectivePort;
+        this.refreshActiveRuntime();
+        for (let attempt = 0; attempt < this.portFallbackCount; attempt++) {
+          const candidate = this.preferredPort + attempt;
+          try {
+            await this.bindOnce(candidate, options?.silent === true);
+            this.effectivePort = candidate;
+            this.port = candidate;
+            this.startedAt = Date.now();
+            if (attempt > 0 && !options?.silent) {
+              process.stderr.write(
+                `ws bridge bound to port ${candidate} (preferred ${this.preferredPort} was taken)
+`
+              );
+            }
+            this.afterBind();
+            return candidate;
+          } catch (err) {
+            const e = err;
+            if (e?.code !== "EADDRINUSE") {
+              throw err;
+            }
+            if (!options?.silent) {
+              process.stderr.write(
+                `ws bridge port ${candidate} already in use, trying ${candidate + 1}
+`
+              );
+            }
+          }
+        }
+        throw new Error(
+          `could not bind ws bridge after ${this.portFallbackCount} attempts starting at ${this.preferredPort}`
+        );
+      }
+      bindOnce(port, _silent) {
+        return new Promise((resolve2, reject) => {
+          const server = (0, import_http2.createServer)((req, res) => this.handleHttpRequest(req, res));
+          let settled = false;
+          const onError = (err) => {
+            if (settled) return;
+            settled = true;
+            try {
+              server.close();
+            } catch {
+            }
+            this.httpServer = null;
+            this.wss = null;
+            reject(err);
+          };
+          server.once("error", onError);
+          server.listen(port, "127.0.0.1", () => {
+            if (settled) return;
+            settled = true;
+            server.removeListener("error", onError);
+            server.on("error", (err) => {
+              process.stderr.write(`ws bridge http error: ${String(err)}
+`);
+            });
+            this.httpServer = server;
+            this.wss = new import_ws.WebSocketServer({ server });
+            this.wireWebSocketServer();
+            resolve2();
+          });
+        });
+      }
+      /** attach the WS connection handler to the current wss. called from
+       *  bindOnce() after WebSocketServer is freshly created. */
+      wireWebSocketServer() {
+        if (!this.wss) return;
+        this.wss.on("connection", (ws, req) => {
+          const origin = req.headers.origin;
+          const role = origin ? "browser" : "cli";
+          let browser = null;
+          this.agentHost.registerSocket(ws);
+          if (role === "browser") {
+            browser = {
+              id: `tab-${this.nextBrowserId++}`,
+              ws,
+              origin,
+              connectedAt: Date.now(),
+              lastSeenAt: Date.now(),
+              lastActiveAt: 0,
+              recentActions: []
+            };
+            this.browsers.set(browser.id, browser);
+            if (this.shouldPromoteBrowser(browser)) {
+              this.primaryBrowserId = browser.id;
+            }
+            this.broadcastBrowserAssignments();
+            this.broadcastBrowserClientStates();
+          } else {
+            const fallbackKey = `ws-${this.nextCliFallbackId++}`;
+            this.cliSessionKeyBySocket.set(ws, fallbackKey);
+          }
+          ws.on("message", (data) => {
+            let msg;
+            try {
+              msg = JSON.parse(data.toString());
+            } catch {
+              return;
+            }
+            if (!msg || typeof msg !== "object") return;
+            if (typeof msg.type === "string" && msg.type.startsWith("agent:")) {
+              void this.agentHost.handleMessage(ws, msg);
+              return;
+            }
+            if (msg.type === "runtime:list") {
+              const versions = listInstalledRuntimes();
+              const active = this.getActiveRuntime();
+              const reply = {
+                type: "runtime:list:ok",
+                id: msg.id,
+                installed: versions,
+                active: active.version,
+                activeRuntimeDir: active.runtimeDir
+              };
+              try {
+                ws.send(JSON.stringify(reply));
+              } catch {
+              }
+              return;
+            }
+            if (msg.type === "runtime:use") {
+              const version = typeof msg.version === "string" ? msg.version : "";
+              const installed = listInstalledRuntimes();
+              if (!installed.includes(version)) {
+                try {
+                  ws.send(
+                    JSON.stringify({
+                      type: "runtime:use:error",
+                      id: msg.id,
+                      error: `runtime ${version || "(missing)"} is not installed`
+                    })
+                  );
+                } catch {
+                }
+                return;
+              }
+              const result = this.setActiveRuntime(version);
+              try {
+                ws.send(
+                  JSON.stringify({
+                    type: "runtime:use:ok",
+                    id: msg.id,
+                    version: result.version,
+                    runtimeDir: result.runtimeDir
+                  })
+                );
+              } catch {
+              }
+              return;
+            }
+            if (msg.type === "runtime:get") {
+              const active = this.getActiveRuntime();
+              try {
+                ws.send(
+                  JSON.stringify({
+                    type: "runtime:get:ok",
+                    id: msg.id,
+                    active: active.version,
+                    activeRuntimeDir: active.runtimeDir
+                  })
+                );
+              } catch {
+              }
+              return;
+            }
+            if (role === "browser") {
+              if (browser) {
+                browser.lastSeenAt = Date.now();
+              }
+              if (msg.type === "bridge:register" && browser) {
+                const registration = msg;
+                const restored = this.tryRestoreBrowserId(browser, registration.browserId);
+                browser.url = registration.url;
+                browser.title = registration.title;
+                browser.userAgent = registration.userAgent;
+                if (restored) {
+                  this.broadcastBrowserAssignments();
+                  this.broadcastBrowserClientStates();
+                }
+                return;
+              }
+              if (msg.type === "bridge:user-focus-state" && browser) {
+                const focusState = msg;
+                this.updateUserFocusLease(browser, focusState.focused === true);
+                return;
+              }
+              if (msg.type === "bridge:user-interact" && browser) {
+                this.updateUserActivity(browser);
+                return;
+              }
+              if (msg.type === "bridge:open-path") {
+                const filePath = typeof msg.path === "string" ? msg.path : "";
+                const line = typeof msg.line === "number" && Number.isFinite(msg.line) ? msg.line : void 0;
+                const column = typeof msg.column === "number" && Number.isFinite(msg.column) ? msg.column : void 0;
+                if (filePath) {
+                  void this.openPathInEditor(filePath, line, column);
+                }
+                return;
+              }
+              if (msg.type === "bridge:boot-clients" && browser) {
+                const booted = [];
+                for (const [cliWs, attachedBrowserId] of this.cliBrowserBySocket) {
+                  if (attachedBrowserId === browser.id) {
+                    booted.push(cliWs);
+                  }
+                }
+                for (const cliWs of booted) {
+                  this.cliBrowserBySocket.delete(cliWs);
+                  try {
+                    cliWs.close(1e3, "booted by browser");
+                  } catch {
+                  }
+                }
+                const hadLease = !!browser.cliLease;
+                browser.cliLease = void 0;
+                if (booted.length > 0 || hadLease) {
+                  process.stderr.write(
+                    `sootsim booted ${booted.length} cli client(s)${hadLease ? " + cleared lease" : ""} from [${browser.id}]
+`
+                  );
+                  this.recordBrowserAction(browser.id, "browser booted cli clients");
+                  this.broadcastBrowserClientStates();
+                }
+                return;
+              }
+              const internalPending = this.pendingCommands.get(msg.id);
+              if (internalPending) {
+                this.pendingCommands.delete(msg.id);
+                if (msg.error) internalPending.reject(new Error(msg.error));
+                else internalPending.resolve(msg.result);
+                return;
+              }
+              const entry = this.cliBySentId.get(msg.id);
+              if (entry) {
+                this.cliBySentId.delete(msg.id);
+                if (entry.ws.readyState === import_ws.WebSocket.OPEN) {
+                  const otherCliCount = this.getOtherCliSessionCount(
+                    entry.ws,
+                    entry.browserId
+                  );
+                  const response = otherCliCount > 0 ? { ...msg, id: entry.originalId, _otherCliCount: otherCliCount } : { ...msg, id: entry.originalId };
+                  entry.ws.send(JSON.stringify(response));
+                }
+              }
+              return;
+            }
+            void (async () => {
+              this.cliLastCommandAt.set(ws, Date.now());
+              try {
+                if (msg.type === "bridge:bye") {
+                  const hadBrowser = this.cliBrowserBySocket.delete(ws);
+                  this.cliLastCommandAt.delete(ws);
+                  this.cliSessionKeyBySocket.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();
+                  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);
+                  if (typeof msg.cliLabel === "string" && msg.cliLabel.trim()) {
+                    this.cliLabelBySocket.set(ws, msg.cliLabel.trim());
+                  }
+                  if (ws.readyState === import_ws.WebSocket.OPEN) {
+                    ws.send(
+                      JSON.stringify({
+                        id: msg.id,
+                        result: {
+                          cliSessionKey: key,
+                          leaseTtlMs: _SootSimBridgeHost.CLI_LEASE_TTL_MS,
+                          leasing: true
+                        }
+                      })
+                    );
+                  }
+                  return;
+                }
+                if (msg.type === "bridge:list-browsers") {
+                  if (ws.readyState === import_ws.WebSocket.OPEN) {
+                    ws.send(
+                      JSON.stringify({
+                        id: msg.id,
+                        result: this.listBrowsers()
+                      })
+                    );
+                  }
+                  return;
+                }
+                if (msg.type === "bridge:open") {
+                  if (typeof msg.url !== "string" || !msg.url) {
+                    throw new Error("bridge:open requires a url");
+                  }
+                  await this.openUrl(msg.url);
+                  if (ws.readyState === import_ws.WebSocket.OPEN) {
+                    ws.send(
+                      JSON.stringify({
+                        id: msg.id,
+                        result: { ok: true, url: msg.url }
+                      })
+                    );
+                  }
+                  return;
+                }
+                if (msg.type === "bridge:claim") {
+                  const targetBrowser2 = await this.waitForBrowser(msg.browserId);
+                  const outcome = this.tryAcquireLease(ws, targetBrowser2, {
+                    force: msg.force === true
+                  });
+                  if (!outcome.granted) {
+                    if (ws.readyState === import_ws.WebSocket.OPEN) {
+                      ws.send(
+                        JSON.stringify({
+                          id: msg.id,
+                          error: `tab ${targetBrowser2.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"
+                  );
+                  if (ws.readyState === import_ws.WebSocket.OPEN) {
+                    ws.send(
+                      JSON.stringify({
+                        id: msg.id,
+                        result: {
+                          browserId: targetBrowser2.id,
+                          lockedBy: outcome.lease.cliSessionKey,
+                          lockExpiresAt: outcome.lease.expiresAt,
+                          bootedCount: outcome.bootedCount
+                        }
+                      })
+                    );
+                  }
+                  return;
+                }
+                const targetBrowser = await this.waitForBrowser(msg.browserId);
+                if (shouldAcquireLease(msg)) {
+                  const outcome = this.tryAcquireLease(ws, targetBrowser);
+                  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\``,
+                          _locked: outcome.lock
+                        })
+                      );
+                    }
+                    return;
+                  }
+                } else {
+                  this.ensureCliSessionKey(ws);
+                }
+                this.setCliBrowserTarget(ws, targetBrowser.id);
+                this.recordBrowserAction(targetBrowser.id, this.describeForwardedCommand(msg));
+                const sentId = this.nextCommandId++;
+                this.cliBySentId.set(sentId, {
+                  browserId: targetBrowser.id,
+                  ws,
+                  originalId: msg.id
+                });
+                const { browserId: _browserId, ...forwarded } = msg;
+                targetBrowser.ws.send(JSON.stringify({ ...forwarded, id: sentId }));
+              } catch (err) {
+                if (ws.readyState === import_ws.WebSocket.OPEN) {
+                  ws.send(
+                    JSON.stringify({
+                      id: msg.id,
+                      error: err instanceof Error ? err.message : String(err)
+                    })
+                  );
+                }
+              }
+            })();
+          });
+          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;
+              }
+              for (const [id, pending] of this.pendingCommands) {
+                if (pending.browserId !== browser.id) continue;
+                pending.reject(new Error("browser disconnected"));
+                this.pendingCommands.delete(id);
+              }
+              for (const [sentId, entry] of this.cliBySentId) {
+                if (entry.browserId !== browser.id) continue;
+                if (entry.ws.readyState === import_ws.WebSocket.OPEN) {
+                  entry.ws.send(
+                    JSON.stringify({
+                      id: entry.originalId,
+                      error: "browser disconnected before responding"
+                    })
+                  );
+                }
+                this.cliBySentId.delete(sentId);
+              }
+              this.broadcastBrowserAssignments();
+              this.broadcastBrowserClientStates();
+            } else if (role === "cli") {
+              const detached = this.cliBrowserBySocket.delete(ws);
+              this.cliLastCommandAt.delete(ws);
+              this.cliSessionKeyBySocket.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();
+              }
+            }
+          });
+        });
+      }
+      /** after a successful bind: start the cli idle sweep, write the daemon
+       *  lockfile (if this host owns it), seed the agent host, kick off the
+       *  heartbeat loop. idempotent across rebinds because close() tears down
+       *  every timer and the lockfile. */
+      afterBind() {
+        process.stderr.write(`ws bridge listening on port ${this.port}
+`);
+        this.cliIdleTimer = setInterval(
+          () => this.sweepIdleCliClients(),
+          3e4
+        );
+        this.cliIdleTimer.unref();
+        if (this.shouldWriteLockfile) {
+          try {
+            ensureSootsimHome();
+            const claimed = claimDaemonLockfile(this.buildLockfileSnapshot());
+            if (!claimed) {
+              throw new Error(
+                "another sootsim daemon wrote the lockfile during startup \u2014 aborting"
+              );
+            }
+          } catch (err) {
+            process.stderr.write(
+              `ws bridge failed to claim daemon lockfile: ${String(err)}
+`
+            );
+            throw err;
+          }
+          this.heartbeatTimer = setInterval(() => {
+            try {
+              this.writeLockfileSnapshot();
+            } catch {
+            }
+          }, DAEMON_HEARTBEAT_INTERVAL_MS);
+          this.heartbeatTimer.unref();
+        }
+        void this.agentHost.seedOnBoot();
+      }
+      buildLockfileSnapshot() {
+        return {
+          schema: 1,
+          pid: process.pid,
+          platform: process.platform,
+          bridgePort: this.effectivePort,
+          runtimePort: this.effectivePort,
+          activeRuntime: this.activeRuntimeVersion,
+          activeRuntimeDir: this.activeRuntimeDirPath,
+          startedAt: this.startedAt,
+          heartbeatAt: Date.now()
+        };
+      }
+      writeLockfileSnapshot() {
+        writeDaemonLockfile(this.buildLockfileSnapshot());
+      }
+      refreshActiveRuntime() {
+        this.activeRuntimeVersion = readActiveRuntime();
+        this.activeRuntimeDirPath = activeRuntimeDir();
+      }
+      /** 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. */
+      setActiveRuntime(version) {
+        writeActiveRuntime(version);
+        this.refreshActiveRuntime();
+        if (this.shouldWriteLockfile && this.httpServer) {
+          try {
+            this.writeLockfileSnapshot();
+          } catch {
+          }
+        }
+        const payload = JSON.stringify({
+          type: "runtime:changed",
+          version,
+          runtimeDir: this.activeRuntimeDirPath
+        });
+        for (const browser of this.browsers.values()) {
+          if (browser.ws.readyState === import_ws.WebSocket.OPEN) {
+            try {
+              browser.ws.send(payload);
+            } catch {
+            }
+          }
+        }
+        return { version, runtimeDir: this.activeRuntimeDirPath };
+      }
+      getActiveRuntime() {
+        return {
+          version: this.activeRuntimeVersion,
+          runtimeDir: this.activeRuntimeDirPath
+        };
+      }
+      /** last-ditch lockfile cleanup. safe to call from a synchronous
+       *  `process.on('exit', ...)` handler since it only does a fs.unlinkSync. */
+      removeLockfile() {
+        if (!this.shouldWriteLockfile) return;
+        try {
+          removeDaemonLockfile();
+        } catch {
+        }
+      }
+      /** minimal HTTP request handler attached to the same node http server
+       *  that hosts the WS upgrade. handles:
+       *    GET /healthz        json status for supervisors / curl
+       *    GET / + everything  serves from the active runtime dist, SPA fallback
+       *  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) {
+        const method = (req.method || "GET").toUpperCase();
+        if (method !== "GET" && method !== "HEAD") {
+          res.writeHead(405, { Allow: "GET, HEAD" });
+          res.end("method not allowed");
+          return;
+        }
+        const url = new URL(req.url || "/", "http://localhost");
+        if (url.pathname === "/__bundle-proxy") {
+          const target = url.searchParams.get("url");
+          if (!target) {
+            res.writeHead(400, { "Content-Type": "text/plain" });
+            res.end("bundle-proxy: missing url query param");
+            return;
+          }
+          let parsedTarget;
+          try {
+            parsedTarget = new URL(target);
+          } catch {
+            res.writeHead(400, { "Content-Type": "text/plain" });
+            res.end("bundle-proxy: invalid url");
+            return;
+          }
+          const host = parsedTarget.hostname;
+          const isLoopback = host === "localhost" || host === "127.0.0.1" || host === "::1" || host.endsWith(".localhost");
+          if (!isLoopback) {
+            res.writeHead(403, { "Content-Type": "text/plain" });
+            res.end("bundle-proxy: only loopback targets allowed");
+            return;
+          }
+          void (async () => {
+            try {
+              const upstream = await fetch(parsedTarget.toString(), {
+                redirect: "follow"
+              });
+              const headers = {};
+              const ct = upstream.headers.get("content-type");
+              if (ct) headers["Content-Type"] = ct;
+              headers["Cache-Control"] = "no-store";
+              res.writeHead(upstream.status, headers);
+              if (!upstream.body) {
+                res.end();
+                return;
+              }
+              const reader = upstream.body.getReader();
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                res.write(Buffer.from(value));
+              }
+              res.end();
+            } catch (err) {
+              res.writeHead(502, { "Content-Type": "text/plain" });
+              res.end(
+                `bundle-proxy: upstream fetch failed: ${err instanceof Error ? err.message : String(err)}`
+              );
+            }
+          })();
+          return;
+        }
+        if (url.pathname === "/healthz") {
+          res.writeHead(200, {
+            "Content-Type": "application/json",
+            "Cache-Control": "no-store"
+          });
+          res.end(
+            JSON.stringify({
+              ok: true,
+              pid: process.pid,
+              platform: process.platform,
+              bridgePort: this.effectivePort,
+              runtimePort: this.effectivePort,
+              activeRuntime: this.activeRuntimeVersion,
+              startedAt: this.startedAt,
+              uptimeMs: this.startedAt > 0 ? Date.now() - this.startedAt : 0
+            })
+          );
+          return;
+        }
+        this.refreshActiveRuntime();
+        const baseDir = this.activeRuntimeDirPath;
+        if (!baseDir) {
+          res.writeHead(503, { "Content-Type": "text/plain; charset=utf-8" });
+          res.end(
+            "sootsim: no active runtime installed. run `sootsim runtime install` to fetch one."
+          );
+          return;
+        }
+        let rel = url.pathname;
+        if (rel === "/runtime" || rel === "/runtime/") rel = "/";
+        else if (rel.startsWith("/runtime/")) rel = rel.slice("/runtime".length);
+        if (rel === "" || rel === "/") rel = "/index.html";
+        if (rel.includes("\0")) {
+          res.writeHead(400);
+          res.end("bad request");
+          return;
+        }
+        if (process.platform !== "win32" && rel.includes("\\")) {
+          res.writeHead(400);
+          res.end("bad request");
+          return;
+        }
+        for (const segment of rel.split("/")) {
+          if (segment === "..") {
+            res.writeHead(403);
+            res.end("forbidden");
+            return;
+          }
+        }
+        const resolved = import_path2.default.resolve(baseDir, "." + rel);
+        const baseWithSep = baseDir.endsWith(import_path2.default.sep) ? baseDir : baseDir + import_path2.default.sep;
+        if (!resolved.startsWith(baseWithSep) && resolved !== baseDir) {
+          res.writeHead(403);
+          res.end("forbidden");
+          return;
+        }
+        import_fs2.default.realpath(resolved, (realErr, realResolved) => {
+          const servePath = realErr ? resolved : realResolved;
+          const servePathWithSep = servePath.endsWith(import_path2.default.sep) ? servePath : servePath + import_path2.default.sep;
+          if (!realErr) {
+            const realBaseWithSep = (() => {
+              try {
+                const rb = import_fs2.default.realpathSync(baseDir);
+                return rb.endsWith(import_path2.default.sep) ? rb : rb + import_path2.default.sep;
+              } catch {
+                return baseWithSep;
+              }
+            })();
+            if (!servePathWithSep.startsWith(realBaseWithSep) && servePath + import_path2.default.sep !== realBaseWithSep) {
+              res.writeHead(403);
+              res.end("forbidden");
+              return;
+            }
+          }
+          import_fs2.default.stat(servePath, (err, stats) => {
+            if (err || !stats?.isFile()) {
+              const ext2 = import_path2.default.extname(rel).toLowerCase();
+              if (ext2 && ext2 !== ".html") {
+                res.writeHead(404);
+                res.end("not found");
+                return;
+              }
+              const indexPath = import_path2.default.join(baseDir, "index.html");
+              import_fs2.default.readFile(indexPath, (err2, data) => {
+                if (err2) {
+                  res.writeHead(404);
+                  res.end("not found");
+                  return;
+                }
+                res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                if (method === "HEAD") {
+                  res.end();
+                  return;
+                }
+                res.end(data);
+              });
+              return;
+            }
+            const ext = import_path2.default.extname(servePath).toLowerCase();
+            const contentType = HTTP_MIME_TYPES[ext] || "application/octet-stream";
+            res.writeHead(200, { "Content-Type": contentType });
+            if (method === "HEAD") {
+              res.end();
+              return;
+            }
+            const stream = import_fs2.default.createReadStream(servePath);
+            stream.pipe(res);
+            stream.on("error", () => {
+              try {
+                res.end();
+              } catch {
+              }
+            });
+          });
+        });
+      }
+      sweepIdleCliClients() {
+        const now = Date.now();
+        let swept = false;
+        for (const [ws, browserId] of this.cliBrowserBySocket) {
+          const lastCommand = this.cliLastCommandAt.get(ws) ?? 0;
+          if (now - lastCommand < _SootSimBridgeHost.CLI_IDLE_TIMEOUT_MS) continue;
+          this.cliBrowserBySocket.delete(ws);
+          this.cliLastCommandAt.delete(ws);
+          for (const [sentId, entry] of this.cliBySentId) {
+            if (entry.ws === ws) this.cliBySentId.delete(sentId);
+          }
+          try {
+            ws.close(1e3, "idle timeout");
+          } catch {
+          }
+          swept = true;
+        }
+        if (swept) {
+          this.broadcastBrowserClientStates();
+        }
+        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;
+          return a.connectedAt - b.connectedAt;
+        }).map((browser) => this.describeBrowser(browser));
+      }
+      async sendCommand(cmd) {
+        const browser = await this.waitForBrowser(cmd.browserId);
+        const id = this.nextCommandId++;
+        return new Promise((resolve2, reject) => {
+          const timeout = setTimeout(() => {
+            this.pendingCommands.delete(id);
+            this.broadcastBrowserClientStates();
+            reject(new Error("command timed out after 30s"));
+          }, 3e4);
+          this.pendingCommands.set(id, {
+            browserId: browser.id,
+            resolve: (value) => {
+              clearTimeout(timeout);
+              this.pendingCommands.delete(id);
+              this.broadcastBrowserClientStates();
+              resolve2(value);
+            },
+            reject: (error) => {
+              clearTimeout(timeout);
+              this.pendingCommands.delete(id);
+              this.broadcastBrowserClientStates();
+              reject(error);
+            }
+          });
+          this.broadcastBrowserClientStates();
+          const { browserId: _browserId, ...forwarded } = cmd;
+          browser.ws.send(JSON.stringify({ ...forwarded, id }));
+        });
+      }
+      async evaluate(code, browserId) {
+        return this.sendCommand({ type: "evaluate", code, browserId });
+      }
+      async focusBrowser(browserId) {
+        return this.sendCommand({ type: "focus", browserId });
+      }
+      async closeBrowser(browserId) {
+        return this.sendCommand({ type: "close", browserId });
+      }
+      async openPathInEditor(filePath, line, column) {
+        const loc = line != null ? `:${line}${column != null ? `:${column}` : ""}` : "";
+        const target = `${filePath}${loc}`;
+        const trySpawn = (cmd, args) => new Promise((resolve2) => {
+          try {
+            const child = (0, import_child_process2.spawn)(cmd, args, { detached: true, stdio: "ignore" });
+            let settled = false;
+            child.on("error", () => {
+              if (settled) return;
+              settled = true;
+              resolve2(false);
+            });
+            child.on("spawn", () => {
+              if (settled) return;
+              settled = true;
+              child.unref();
+              resolve2(true);
+            });
+          } catch {
+            resolve2(false);
+          }
+        });
+        const envEditor = process.env.REACT_EDITOR || process.env.EDITOR;
+        if (envEditor) {
+          const parts = envEditor.split(" ").filter(Boolean);
+          if (parts.length && await trySpawn(parts[0], [...parts.slice(1), "-g", target]))
+            return;
+        }
+        if (await trySpawn("cursor", ["-g", target])) return;
+        if (await trySpawn("code", ["-g", target])) return;
+        await this.openUrl(filePath);
+      }
+      async openUrl(url) {
+        if (this.openUrlHandler) {
+          await this.openUrlHandler(url);
+          return;
+        }
+        if (process.platform === "darwin") {
+          const child2 = (0, import_child_process2.spawn)("open", ["-g", url], { detached: true, stdio: "ignore" });
+          child2.unref();
+          return;
+        }
+        if (process.platform === "win32") {
+          const child2 = (0, import_child_process2.spawn)("cmd", ["/c", "start", "", url], {
+            detached: true,
+            stdio: "ignore"
+          });
+          child2.unref();
+          return;
+        }
+        const child = (0, import_child_process2.spawn)("xdg-open", [url], { detached: true, stdio: "ignore" });
+        child.unref();
+      }
+      async close() {
+        if (this.cliIdleTimer) {
+          clearInterval(this.cliIdleTimer);
+          this.cliIdleTimer = null;
+        }
+        if (this.heartbeatTimer) {
+          clearInterval(this.heartbeatTimer);
+          this.heartbeatTimer = null;
+        }
+        if (this.shouldWriteLockfile) {
+          try {
+            removeDaemonLockfile();
+          } catch {
+          }
+        }
+        this.effectivePort = 0;
+        this.startedAt = 0;
+        this.agentHost.close();
+        for (const [id, pending] of this.pendingCommands) {
+          pending.reject(new Error("server closing"));
+          this.pendingCommands.delete(id);
+        }
+        for (const browser of this.browsers.values()) {
+          browser.ws.close();
+        }
+        this.browsers.clear();
+        this.primaryBrowserId = null;
+        const wss = this.wss;
+        const httpServer = this.httpServer;
+        this.wss = null;
+        this.httpServer = null;
+        if (wss) {
+          try {
+            wss.close();
+          } catch {
+          }
+        }
+        if (httpServer) {
+          try {
+            httpServer.close();
+          } catch {
+          }
+        }
+      }
+      describeBrowser(browser) {
+        let readyState;
+        try {
+          readyState = browser.ws.readyState;
+        } catch {
+          readyState = import_ws.WebSocket.CLOSED;
+        }
+        const lease = this.getActiveLease(browser);
+        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,
+          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,
+          lockedByKind: lease ? lease.kind : void 0,
+          lockExpiresAt: lease ? lease.expiresAt : void 0,
+          userFocused: browser.userFocused || void 0
+        };
+      }
+      getActiveLease(browser) {
+        const lease = browser.cliLease;
+        if (!lease) return null;
+        if (Date.now() >= lease.expiresAt) {
+          browser.cliLease = void 0;
+          return null;
+        }
+        return lease;
+      }
+      tryAcquireLease(ws, browser, opts = {}) {
+        const cliSessionKey = this.cliSessionKeyBySocket.get(ws) ?? (() => {
+          const fallback = `ws-${this.nextCliFallbackId++}`;
+          this.cliSessionKeyBySocket.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;
+        let bootedCount = 0;
+        if (existing && !ownerMatches && !opts.force) {
+          return {
+            granted: false,
+            lease: existing,
+            lock: {
+              by: existing.cliLabel || existing.cliSessionKey,
+              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);
+              try {
+                cliWs.close(1e3, "lease claimed by another cli");
+              } catch {
+              }
+              bootedCount++;
+            }
+          }
+        }
+        const lease = {
+          kind: "cli",
+          cliSessionKey,
+          cliLabel,
+          expiresAt: now + _SootSimBridgeHost.CLI_LEASE_TTL_MS
+        };
+        browser.cliLease = lease;
+        return { granted: true, lease, bootedCount };
+      }
+      // user focus is advisory: we track it on the browser 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
+      // 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) {
+        const next = focused;
+        if (browser.userFocused === next) return;
+        browser.userFocused = next;
+        this.broadcastBrowserClientStates();
+      }
+      // called when the browser 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.
+      // reads still pass through — shouldAcquireLease only blocks on writes.
+      updateUserActivity(browser) {
+        const existing = this.getActiveLease(browser);
+        if (existing && existing.kind === "cli") {
+          return;
+        }
+        browser.cliLease = {
+          kind: "user-active",
+          cliSessionKey: "__user-active__",
+          cliLabel: "active user",
+          expiresAt: Date.now() + _SootSimBridgeHost.USER_ACTIVE_LEASE_TTL_MS
+        };
+        this.broadcastBrowserClientStates();
+      }
+      ensureCliSessionKey(ws) {
+        const existing = this.cliSessionKeyBySocket.get(ws);
+        if (existing) return existing;
+        const fallback = `ws-${this.nextCliFallbackId++}`;
+        this.cliSessionKeyBySocket.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;
+          return null;
+        }
+        const primary = this.primaryBrowserId != null ? this.browsers.get(this.primaryBrowserId) : 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;
+        }
+        return null;
+      }
+      async waitForBrowser(browserId, 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;
+          await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
+        }
+        throw new Error(
+          browserId ? `no browser connected with id ${browserId}` : "no browser connected"
+        );
+      }
+      shouldPromoteBrowser(browser) {
+        const current = this.primaryBrowserId ? this.browsers.get(this.primaryBrowserId) : null;
+        const isPrimaryCandidate = browser.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(
+            JSON.stringify({
+              type: "bridge:welcome",
+              browserId: browser.id,
+              isPrimary: browser.id === this.primaryBrowserId
+            })
+          );
+        }
+      }
+      broadcastBrowserClientStates() {
+        for (const browser of this.browsers.values()) {
+          if (browser.ws.readyState !== import_ws.WebSocket.OPEN) continue;
+          const lease = this.getActiveLease(browser);
+          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,
+            lockedByKind: lease ? lease.kind : void 0,
+            lockExpiresAt: lease ? lease.expiresAt : void 0,
+            userFocused: browser.userFocused || void 0
+          };
+          browser.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();
+      }
+      recordBrowserAction(browserId, label, broadcast = true) {
+        const normalized = label?.trim();
+        if (!normalized) return;
+        const browser = this.browsers.get(browserId);
+        if (!browser) return;
+        const now = Date.now();
+        browser.lastActiveAt = now;
+        browser.recentActions = [
+          { label: normalized, at: now },
+          ...browser.recentActions.filter((entry) => entry.label !== normalized)
+        ].slice(0, 4);
+        if (broadcast) this.broadcastBrowserClientStates();
+      }
+      describeForwardedCommand(msg) {
+        switch (msg?.type) {
+          case "evaluate":
+            return "evaluated page state";
+          case "screenshot":
+            return "captured screenshot";
+          case "tap":
+            return "sent tap event";
+          case "keyboard":
+            return msg?.action === "type" ? "typed text" : "used keyboard";
+          case "tree":
+            return "dumped tree";
+          case "focus":
+            return "focused tab";
+          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.
+      // 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) {
+        const keys = /* @__PURE__ */ new Set();
+        for (const [ws, attachedBrowserId] of this.cliBrowserBySocket) {
+          if (attachedBrowserId !== browserId) continue;
+          if (ws.readyState !== import_ws.WebSocket.OPEN) continue;
+          const key = this.cliSessionKeyBySocket.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);
+        const keys = /* @__PURE__ */ new Set();
+        for (const [ws, attachedBrowserId] of this.cliBrowserBySocket) {
+          if (attachedBrowserId !== browserId) continue;
+          if (ws.readyState !== import_ws.WebSocket.OPEN) continue;
+          const key = this.cliSessionKeyBySocket.get(ws);
+          if (key && key === selfKey) continue;
+          keys.add(key ?? `ws-unknown-${keys.size}`);
+        }
+        return keys.size;
+      }
+      getActiveAgentCommandCount(browserId) {
+        let count = 0;
+        for (const pending of this.pendingCommands.values()) {
+          if (pending.browserId === browserId) count++;
+        }
+        return count;
+      }
+      tryRestoreBrowserId(browser, 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) {
+          return false;
+        }
+        const restorable = this.getRestorableBrowserState(nextId);
+        const prevId = browser.id;
+        this.browsers.delete(prevId);
+        browser.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);
+        }
+        this.browsers.set(browser.id, browser);
+        if (this.primaryBrowserId === prevId) {
+          this.primaryBrowserId = browser.id;
+        }
+        for (const [ws, attachedBrowserId] of this.cliBrowserBySocket) {
+          if (attachedBrowserId === prevId) {
+            this.cliBrowserBySocket.set(ws, browser.id);
+          }
+        }
+        return true;
+      }
+      rememberDisconnectedBrowser(browser) {
+        const lease = this.getActiveLease(browser);
+        this.restorableBrowsers.set(browser.id, {
+          recentActions: browser.recentActions.map((entry) => ({ ...entry })),
+          lastActiveAt: browser.lastActiveAt,
+          cliLease: lease && lease.kind === "cli" ? { ...lease } : void 0,
+          expiresAt: Date.now() + _SootSimBridgeHost.BROWSER_RECONNECT_TTL_MS
+        });
+        this.browsers.delete(browser.id);
+      }
+      getRestorableBrowserState(browserId) {
+        const snapshot = this.restorableBrowsers.get(browserId);
+        if (!snapshot) return null;
+        if (snapshot.expiresAt <= Date.now()) {
+          this.restorableBrowsers.delete(browserId);
+          return null;
+        }
+        if (snapshot.cliLease && snapshot.cliLease.expiresAt <= Date.now()) {
+          snapshot.cliLease = void 0;
+        }
+        return snapshot;
+      }
+      sweepRestorableBrowsers(now = Date.now()) {
+        for (const [browserId, snapshot] of this.restorableBrowsers) {
+          if (snapshot.expiresAt > now) continue;
+          this.restorableBrowsers.delete(browserId);
+          for (const [cliWs, attachedBrowserId] of this.cliBrowserBySocket) {
+            if (attachedBrowserId === browserId) {
+              this.cliBrowserBySocket.delete(cliWs);
+            }
+          }
+        }
+      }
+      resetServerState() {
+        if (this.cliIdleTimer) {
+          clearInterval(this.cliIdleTimer);
+          this.cliIdleTimer = null;
+        }
+        const wss = this.wss;
+        const httpServer = this.httpServer;
+        this.wss = null;
+        this.httpServer = null;
+        if (wss) {
+          try {
+            wss.close();
+          } catch {
+          }
+        }
+        if (httpServer) {
+          try {
+            httpServer.close();
+          } catch {
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/vite-plugin.ts
+var vite_plugin_exports = {};
+__export(vite_plugin_exports, {
+  fixJsxRuntimeExports: () => fixJsxRuntimeExports,
+  sootsim: () => sootsim,
+  workerReactBridgePlugin: () => workerReactBridgePlugin,
+  wsBridgePlugin: () => wsBridgePlugin
+});
+module.exports = __toCommonJS(vite_plugin_exports);
+var import_fs3 = __toESM(require("fs"), 1);
+var import_path3 = __toESM(require("path"), 1);
+var import_url = require("url");
+var import_vite = require("vite");
+init_bridge_constants();
+var sootsimRoot = import_path3.default.resolve(import_path3.default.dirname((0, import_url.fileURLToPath)(__sootsim_import_meta_url)), "..");
+var workspaceRoot = import_path3.default.resolve(sootsimRoot, "..", "..");
+var workspaceNodeModules = import_path3.default.resolve(workspaceRoot, "node_modules");
+var workspaceTamaguiDir = import_path3.default.resolve(workspaceNodeModules, "@tamagui");
+var engineRoot = import_path3.default.resolve(workspaceRoot, "packages/sootsim-engine");
+var rnShimPath = import_path3.default.resolve(engineRoot, "src/react-native/index.ts");
+var reactBridgePath = import_path3.default.resolve(engineRoot, "src/react-bridge.ts");
+var sootsimBrowserSourceAliases = [
+  {
+    find: "sootsim/backend-origin",
+    replacement: import_path3.default.resolve(sootsimRoot, "src/backend-origin.ts")
+  },
+  {
+    find: "sootsim/bridge-constants",
+    replacement: import_path3.default.resolve(sootsimRoot, "src/bridge-constants.ts")
+  },
+  {
+    find: "sootsim/dev-bundle-resolution",
+    replacement: import_path3.default.resolve(sootsimRoot, "src/dev-bundle-resolution.ts")
+  }
+];
+var compatRoot = import_path3.default.resolve(sootsimRoot, "..", "compat");
+var compatStubsDir = import_path3.default.resolve(compatRoot, "src/stubs");
+var nativeAutoStubPath = import_path3.default.resolve(compatStubsDir, "native-auto-stub.ts");
+var rnDeepStubDefault = import_path3.default.resolve(compatStubsDir, "react-native-internals.ts");
+function getInternalTamaguiPackages() {
+  try {
+    const scoped = import_fs3.default.readdirSync(workspaceTamaguiDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => `@tamagui/${entry.name}`);
+    return ["tamagui", ...scoped].sort();
+  } catch {
+    return ["tamagui"];
+  }
+}
+var internalTamaguiPackages = getInternalTamaguiPackages();
+var rnLibraryStubs = {
+  "react-native/Libraries/Pressability/usePressability": import_path3.default.resolve(
+    compatStubsDir,
+    "rn-libraries/usePressability.ts"
+  ),
+  "react-native/Libraries/Pressability/Pressability": import_path3.default.resolve(
+    compatStubsDir,
+    "rn-libraries/Pressability.ts"
+  ),
+  "react-native/Libraries/Renderer/shims/ReactFabric": import_path3.default.resolve(
+    compatStubsDir,
+    "rn-libraries/ReactFabric.ts"
+  ),
+  "react-native/Libraries/Renderer/shims/ReactNative": import_path3.default.resolve(
+    compatStubsDir,
+    "rn-libraries/ReactNative.ts"
+  )
+};
+var builtinStubs = {
+  "react-native-safe-area-context": "react-native-safe-area-context.ts",
+  "react-native-gesture-handler": "react-native-gesture-handler.ts",
+  "react-native-gesture-handler/ReanimatedSwipeable": "reanimated-swipeable.ts",
+  // NOTE: 'soot-swipeable' is a real workspace package (packages/soot-swipeable),
+  // resolved naturally by vite — no builtin stub entry needed.
+  "react-native-reanimated": "react-native-reanimated.ts",
+  "react-native-screens": "react-native-screens.ts",
+  "@react-native-masked-view/masked-view": "masked-view.ts",
+  "react-native-svg": "react-native-svg.ts",
+  "react-native-keyboard-controller": "react-native-keyboard-controller.ts",
+  "react-native-teleport": "react-native-teleport.tsx",
+  "react-native-ios-context-menu": "react-native-ios-context-menu.ts",
+  "react-native-ios-utilities": "react-native-ios-utilities.ts",
+  "@react-native-menu/menu": "react-native-menu.ts",
+  "expo-splash-screen": "expo-splash-screen.ts",
+  "expo-font": "expo-font.ts",
+  "react-native-launch-arguments": "react-native-launch-arguments.ts",
+  expo: "expo.ts",
+  "@react-native-async-storage/async-storage": "async-storage.ts",
+  "expo-constants": "expo-constants.ts",
+  "expo-image": "expo-image.ts",
+  "expo-linear-gradient": "expo-linear-gradient.ts",
+  "expo-blur": "expo-blur.ts",
+  "expo-liquid-glass-view": "expo-liquid-glass-view.ts",
+  "expo-glass-effect": "expo-glass-effect.ts",
+  "react-native-bottom-tabs": "react-native-bottom-tabs.ts",
+  "@callstack/react-native-bottom-tabs": "react-native-bottom-tabs.ts",
+  "@expo/ui/swift-ui": "expo-ui.ts",
+  "@expo/ui": "expo-ui.ts",
+  "react-native-worklets": "react-native-worklets.ts",
+  "react-native-webview": "react-native-webview.ts",
+  "expo-haptics": "expo-haptics.ts",
+  "expo-crypto": "expo-crypto.ts",
+  "expo-clipboard": "expo-clipboard.ts",
+  "expo-file-system": "expo-file-system.ts",
+  "expo-linking": "expo-linking.ts",
+  "expo-web-browser": "expo-web-browser.ts",
+  "expo-secure-store": "expo-secure-store.ts",
+  "expo-status-bar": "expo-status-bar.ts",
+  "expo-device": "expo-device.ts",
+  "expo-image-picker": "expo-image-picker.ts",
+  "expo-document-picker": "expo-document-picker.ts",
+  "expo-application": "expo-application.ts",
+  "expo-notifications": "expo-notifications.ts",
+  "expo-location": "expo-location.ts",
+  "@shopify/flash-list": "flash-list.ts",
+  "@react-native-community/netinfo": "netinfo.ts",
+  // real package installed, let it resolve naturally
+  "@react-native-community/blur": "react-native-community-blur.ts",
+  "@react-native-community/checkbox": "react-native-community-checkbox.ts",
+  "@react-native-picker/picker": "react-native-picker.ts",
+  "@react-native-community/datetimepicker": "react-native-datetimepicker.ts"
+};
+var coreOwnedPackages = [
+  "react",
+  "react-dom",
+  "react-reconciler",
+  "react/jsx-runtime",
+  "react/jsx-dev-runtime",
+  "canvaskit-wasm",
+  "canvaskit-wasm/full",
+  "yoga-layout"
+];
+var nativePackagePatterns = [
+  /^expo-/,
+  /^react-native-/,
+  /^@react-native\//,
+  /^@react-native-community\//,
+  /^@expo\//,
+  /^expo$/
+];
+function getPackageName(source) {
+  return source.startsWith("@") ? source.split("/").slice(0, 2).join("/") : source.split("/")[0];
+}
+function isNativePackage(source) {
+  return nativePackagePatterns.some((p) => p.test(source));
+}
+function moduleExistsIn(pkgName, dir) {
+  try {
+    return import_fs3.default.existsSync(import_path3.default.join(dir, "node_modules", pkgName));
+  } catch {
+    return false;
+  }
+}
+function sootsim(options = {}) {
+  const appDir = options.app ? import_path3.default.resolve(options.app) : "";
+  const extraSources = (options.sources || []).map((s) => import_path3.default.resolve(s));
+  const ownedPackages = /* @__PURE__ */ new Set([...coreOwnedPackages, ...options.ownedPackages || []]);
+  function isAppSource(filePath) {
+    if (filePath.includes("/node_modules/")) return false;
+    if (appDir && filePath.startsWith(appDir)) return true;
+    return extraSources.some((s) => filePath.startsWith(s));
+  }
+  return [
+    wsBridgePlugin(),
+    reactBridgePlugin(),
+    sootsimConfigPlugin(appDir, extraSources),
+    fixJsxRuntimeExports(),
+    nodeModulesJsxTransform(),
+    metroNativeResolve(isAppSource),
+    reactNativeRequirePlugin(isAppSource),
+    externalAppResolvePlugin(appDir, isAppSource, ownedPackages),
+    externalAppTransformPlugin(isAppSource),
+    stubMissingNativeDeps(appDir),
+    stubMissingImages(isAppSource)
+  ];
+}
+function wsBridgePlugin() {
+  let bridgeHost = null;
+  return {
+    name: "sootsim-ws-bridge",
+    configureServer(server) {
+      if (bridgeHost) return;
+      void Promise.resolve().then(() => (init_bridge_host(), bridge_host_exports)).then(({ SootSimBridgeHost: SootSimBridgeHost2 }) => {
+        bridgeHost = new SootSimBridgeHost2({ port: DEFAULT_SOOTSIM_BRIDGE_PORT });
+        bridgeHost.start?.({ silent: true });
+      }).catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        console.warn("[sootsim] ws bridge failed to start:", message);
+      });
+      server.httpServer?.on("close", () => {
+        if (bridgeHost) {
+          void bridgeHost.close?.();
+          bridgeHost = null;
+        }
+      });
+    }
+  };
+}
+function sootsimConfigPlugin(appDir, extraSources) {
+  return {
+    name: "sootsim-config",
+    config(_, { mode }) {
+      const fsAllow = ["."];
+      for (const src of extraSources) fsAllow.push(src);
+      if (appDir) {
+        fsAllow.push(appDir);
+        const appNodeModules = import_path3.default.join(appDir, "node_modules");
+        if (import_fs3.default.existsSync(appNodeModules)) fsAllow.push(appNodeModules);
+      }
+      const stubAliases = Object.entries(builtinStubs).sort((a, b) => b[0].length - a[0].length).map(([find, file]) => ({
+        find,
+        replacement: import_path3.default.resolve(compatStubsDir, file)
+      }));
+      const dedupe = ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime"];
+      if (!appDir) {
+        dedupe.push(...internalTamaguiPackages);
+      }
+      const optimizeDepsExclude = [
+        "@tamagui/config",
+        "@tamagui/demos",
+        "react-native",
+        // tamagui native variants reference RN internals that the metro transform
+        // handles — must go through sootsim plugin, not rolldown pre-bundling
+        ...!appDir ? internalTamaguiPackages : [],
+        // ships .js with JSX that rolldown can't parse
+        "react-native-actions-sheet",
+        // these packages import `react-native-reanimated` and `react-native-gesture-handler`,
+        // both of which we alias to local stubs. pre-bundling would resolve those imports
+        // against the REAL packages (the alias only applies to main-plugin resolveId), so
+        // the resulting dep has a different reanimated instance than the app graph. keep
+        // them served live so our plugin aliases kick in.
+        "@gorhom/bottom-sheet",
+        "@gorhom/portal"
+      ];
+      return {
+        define: {
+          "process.env.NODE_ENV": JSON.stringify(mode),
+          "process.env.TEST_NATIVE_PLATFORM": JSON.stringify(""),
+          "process.env.TAMAGUI_TARGET": JSON.stringify("native"),
+          global: "globalThis"
+        },
+        optimizeDeps: {
+          include: [
+            "react",
+            "react-dom",
+            "react-dom/client",
+            "react-reconciler",
+            "react-reconciler/constants",
+            "react/jsx-runtime",
+            "react/jsx-dev-runtime",
+            "@react-native/normalize-color",
+            // CJS deps transitively imported by @gorhom/bottom-sheet and
+            // @gorhom/portal (both excluded above). vite's CJS→ESM interop
+            // only kicks in via pre-bundle, so these must be pre-bundled even
+            // though their importers aren't.
+            "invariant",
+            "nanoid/non-secure"
+          ],
+          exclude: optimizeDepsExclude,
+          // vite 8: rolldown replaces esbuild for dep optimization
+          rolldownOptions: {
+            resolve: {
+              conditionNames: ["react-native", "import", "require"],
+              mainFields: ["react-native", "module", "jsnext:main", "jsnext"],
+              extensions: [
+                ".ios.tsx",
+                ".ios.ts",
+                ".ios.jsx",
+                ".ios.js",
+                ".native.tsx",
+                ".native.ts",
+                ".native.jsx",
+                ".native.js",
+                ".native.mjs",
+                ".mjs",
+                ".js",
+                ".mts",
+                ".ts",
+                ".jsx",
+                ".tsx",
+                ".json"
+              ]
+            },
+            plugins: [
+              {
+                name: "sootsim-stub-images",
+                resolveId(source, importer) {
+                  if (/\.(jpg|png|gif)$/.test(source) && importer?.includes("node_modules")) {
+                    return { id: "\0stub-image" };
+                  }
+                },
+                load(id) {
+                  if (id === "\0stub-image") return 'export default ""';
+                }
+              }
+            ]
+          }
+        },
+        build: { target: "esnext" },
+        oxc: { target: "esnext" },
+        server: {
+          fs: { allow: fsAllow }
+        },
+        resolve: {
+          dedupe,
+          conditions: ["react-native", "import", "require"],
+          mainFields: ["react-native", "module", "jsnext:main", "jsnext"],
+          extensions: [
+            ".ios.tsx",
+            ".ios.ts",
+            ".ios.jsx",
+            ".ios.js",
+            ".native.tsx",
+            ".native.ts",
+            ".native.jsx",
+            ".native.js",
+            ".native.mjs",
+            ".mjs",
+            ".js",
+            ".mts",
+            ".ts",
+            ".jsx",
+            ".tsx",
+            ".json"
+          ],
+          alias: [
+            ...sootsimBrowserSourceAliases,
+            ...Object.entries(rnLibraryStubs).map(([find, replacement]) => ({
+              find,
+              replacement
+            })),
+            { find: /^react-native\/Libraries\/.*/, replacement: rnDeepStubDefault },
+            { find: "react-native", replacement: rnShimPath },
+            { find: "react-native-web", replacement: rnShimPath },
+            ...stubAliases
+          ]
+        }
+      };
+    }
+  };
+}
+function reactBridgePlugin() {
+  let isBuild = false;
+  let redirectCount = 0;
+  let skipCount = 0;
+  return {
+    name: "sootsim-react-bridge",
+    enforce: "pre",
+    configResolved(config) {
+      isBuild = config.command === "build";
+      console.log("[react-bridge-plugin] isBuild:", isBuild);
+    },
+    async resolveId(source, importer, options) {
+      if (source !== "react" || !importer) return null;
+      if (importer.includes("/compat/") || importer.includes("/sootsim/src/") || importer.includes("/sootsim-engine/src/")) {
+        skipCount++;
+        if (skipCount <= 5) {
+          const skip = options?.scan || options?.ssr || isBuild;
+          if (!skip) {
+            console.log(
+              "[react-bridge-plugin] react import from:",
+              importer.split("/").slice(-3).join("/"),
+              "skip:",
+              skip
+            );
+          }
+        }
+      }
+      if (options?.scan || options?.ssr || isBuild) return null;
+      const shouldRedirect = importer.includes("/sootsim/src/") || importer.includes("/sootsim-engine/src/") || importer.includes("/compat/src/") || importer.includes("react-reconciler");
+      if (!shouldRedirect) return null;
+      if (importer.includes("react-bridge")) return null;
+      if (importer.includes("stub-registry")) return null;
+      redirectCount++;
+      if (redirectCount <= 10) {
+        console.log(
+          "[react-bridge-plugin] REDIRECTING:",
+          importer.split("/").slice(-3).join("/")
+        );
+      } else if (redirectCount === 11) {
+        console.log("[react-bridge-plugin] ... more redirects");
+      }
+      return { id: reactBridgePath, external: false };
+    }
+  };
+}
+function workerReactBridgePlugin() {
+  return {
+    name: "sootsim-worker-react-bridge",
+    enforce: "pre",
+    async resolveId(source, importer, options) {
+      if (source !== "react" || !importer) return null;
+      if (options?.scan || options?.ssr) return null;
+      const shouldRedirect = importer.includes("/sootsim/src/") || importer.includes("/sootsim-engine/src/") || importer.includes("/compat/src/") || importer.includes("react-reconciler");
+      if (!shouldRedirect) return null;
+      if (importer.includes("react-bridge")) return null;
+      if (importer.includes("stub-registry")) return null;
+      return { id: reactBridgePath, external: false };
+    }
+  };
+}
+function fixJsxRuntimeExports() {
+  return {
+    name: "sootsim-fix-jsx-runtime",
+    enforce: "pre",
+    async resolveId(source, importer, options) {
+      if (source === "react/jsx-runtime" || source === "react/jsx-dev-runtime") {
+        const resolved = await this.resolve(source, importer, {
+          ...options,
+          skipSelf: true
+        });
+        if (!resolved) return null;
+        const prefix = source === "react/jsx-runtime" ? "\0sootsim:jsx-runtime:" : "\0sootsim:jsx-dev-runtime:";
+        return prefix + resolved.id;
+      }
+      return null;
+    },
+    load(id) {
+      if (id.startsWith("\0sootsim:jsx-runtime:")) {
+        const realId = id.slice("\0sootsim:jsx-runtime:".length);
+        return [
+          `import * as _mod from ${JSON.stringify(realId)};`,
+          `const _m = _mod.default || _mod;`,
+          `export const jsx = _m.jsx || _mod.jsx;`,
+          `export const jsxs = _m.jsxs || _mod.jsxs;`,
+          `export const Fragment = _m.Fragment || _mod.Fragment;`
+        ].join("\n");
+      }
+      if (id.startsWith("\0sootsim:jsx-dev-runtime:")) {
+        const realId = id.slice("\0sootsim:jsx-dev-runtime:".length);
+        return [
+          `import * as _mod from ${JSON.stringify(realId)};`,
+          `import * as _runtime from "react/jsx-runtime";`,
+          `const _m = _mod.default || _mod;`,
+          // production React builds may not expose jsxDEV from react/jsx-dev-runtime.
+          // fall back to jsx so transformed modules still execute.
+          `export const jsxDEV = _m.jsxDEV || _mod.jsxDEV || _m.jsx || _mod.jsx || _runtime.jsx;`,
+          `export const Fragment = _m.Fragment || _mod.Fragment || _runtime.Fragment;`
+        ].join("\n");
+      }
+      return null;
+    }
+  };
+}
+function nodeModulesJsxTransform() {
+  return {
+    name: "sootsim-node-modules-jsx",
+    enforce: "pre",
+    async transform(code, id) {
+      if (!id.includes("/node_modules/")) return null;
+      if (!id.endsWith(".js")) return null;
+      if (!code.includes("<")) return null;
+      if (!/[=(\s,]<[A-Z]/.test(code) && !/<\/[A-Z]/.test(code)) return null;
+      const needsReact = !code.includes("import React") && !code.includes("import * as React");
+      const withReact = needsReact ? `import React from 'react';
+${code}` : code;
+      const transformed = await (0, import_vite.transformWithOxc)(withReact, id, {
+        lang: "jsx",
+        jsx: { runtime: "classic" }
+      });
+      return { code: transformed.code, map: transformed.map };
+    }
+  };
+}
+function metroNativeResolve(isAppSource) {
+  const platformExts = [
+    ".ios.tsx",
+    ".ios.ts",
+    ".ios.jsx",
+    ".ios.js",
+    ".native.tsx",
+    ".native.ts",
+    ".native.jsx",
+    ".native.js",
+    ".native.mjs"
+  ];
+  const allExts = [...platformExts, ".tsx", ".ts", ".jsx", ".js", ".mjs", ".cjs"];
+  function tryResolve(base) {
+    for (const ext of platformExts) {
+      const candidate = base + ext;
+      try {
+        if (import_fs3.default.existsSync(candidate)) return candidate;
+      } catch {
+      }
+    }
+    for (const ext of platformExts) {
+      const candidate = import_path3.default.join(base, "index" + ext);
+      try {
+        if (import_fs3.default.existsSync(candidate)) return candidate;
+      } catch {
+      }
+    }
+    return null;
+  }
+  return {
+    name: "sootsim-metro-native-resolve",
+    enforce: "pre",
+    resolveId(source, importer) {
+      if (!importer) return null;
+      if (!importer.includes("node_modules") && !isAppSource(importer)) return null;
+      if (!source.startsWith(".")) return null;
+      if (platformExts.some((ext) => source.endsWith(ext))) return null;
+      const hasBaseExt = allExts.some((ext) => source.endsWith(ext));
+      const dir = import_path3.default.dirname(importer);
+      if (hasBaseExt) {
+        const resolved = import_path3.default.resolve(dir, source);
+        for (const ext of allExts) {
+          if (source.endsWith(ext)) {
+            const found = tryResolve(resolved.slice(0, -ext.length));
+            if (found) return found;
+            break;
+          }
+        }
+      } else {
+        const found = tryResolve(import_path3.default.resolve(dir, source));
+        if (found) return found;
+      }
+      return null;
+    }
+  };
+}
+function reactNativeRequirePlugin(isAppSource) {
+  return {
+    name: "sootsim-react-native-require",
+    enforce: "pre",
+    transform(code, id) {
+      if (!id.includes("node_modules") && !isAppSource(id)) return null;
+      if (!code.includes("react-native")) return null;
+      let hasChanges = false;
+      let imports = "";
+      let result = code;
+      let importCounter = 0;
+      if (result.includes('require("react-native")') || result.includes("require('react-native')")) {
+        imports += `import * as __soot_rn_shim__ from ${JSON.stringify(rnShimPath)};
+`;
+        result = result.replace(/require\(["']react-native["']\)/g, "__soot_rn_shim__");
+        hasChanges = true;
+      }
+      const deepRequireRegex = /require\(["'](react-native\/Libraries\/[^"']+)["']\)/g;
+      const replacements = [];
+      const seenPaths = /* @__PURE__ */ new Map();
+      let match;
+      deepRequireRegex.lastIndex = 0;
+      while ((match = deepRequireRegex.exec(result)) !== null) {
+        const importPath = match[1];
+        if (!seenPaths.has(importPath)) {
+          const varName = `__soot_rn_lib_${importCounter++}__`;
+          const stubPath = rnLibraryStubs[importPath] || rnDeepStubDefault;
+          imports += `import * as ${varName} from ${JSON.stringify(stubPath)};
+`;
+          seenPaths.set(importPath, varName);
+        }
+        replacements.push({
+          full: match[0],
+          path: importPath,
+          varName: seenPaths.get(importPath)
+        });
+      }
+      if (replacements.length > 0) {
+        for (const rep of replacements) {
+          result = result.replace(rep.full, rep.varName);
+        }
+        hasChanges = true;
+      }
+      if (!hasChanges) return null;
+      return { code: imports + result, map: null };
+    }
+  };
+}
+function externalAppResolvePlugin(appDir, isAppSource, ownedPackages) {
+  if (!appDir) return { name: "sootsim-external-app-resolve" };
+  const appVirtualImporter = import_path3.default.join(appDir, "_virtual_.js");
+  return {
+    name: "sootsim-external-app-resolve",
+    enforce: "pre",
+    async resolveId(source, importer, options) {
+      if (!importer) return null;
+      if (source.startsWith(".") || source.startsWith("/") || source.startsWith("\0"))
+        return null;
+      if (ownedPackages.has(source) || ownedPackages.has(getPackageName(source)))
+        return null;
+      if (!isAppSource(importer) && !importer.includes(import_path3.default.join(appDir, "node_modules")))
+        return null;
+      if (source === "react-native" || source.startsWith("react-native/")) return null;
+      const resolved = await this.resolve(source, appVirtualImporter, {
+        ...options,
+        skipSelf: true
+      });
+      return resolved || null;
+    }
+  };
+}
+function externalAppTransformPlugin(isAppSource) {
+  return {
+    name: "sootsim-external-app-transform",
+    enforce: "pre",
+    async transform(code, id) {
+      if (!isAppSource(id)) return null;
+      let result = code;
+      let imports = "";
+      let importCounter = 0;
+      let hasChanges = false;
+      if (code.includes("require(")) {
+        const requireRegex = /require\(["']([^"']+)["']\)/g;
+        const replacements = [];
+        const seenPaths = /* @__PURE__ */ new Map();
+        let match;
+        requireRegex.lastIndex = 0;
+        while ((match = requireRegex.exec(result)) !== null) {
+          const reqPath = match[1];
+          if (reqPath === "react-native" || reqPath.startsWith("react-native/")) continue;
+          if (!seenPaths.has(reqPath)) {
+            const varName = `__soot_cjs_${importCounter++}__`;
+            imports += `import * as ${varName} from ${JSON.stringify(reqPath)};
+`;
+            seenPaths.set(reqPath, varName);
+          }
+          replacements.push({ full: match[0], varName: seenPaths.get(reqPath) });
+        }
+        if (replacements.length > 0) {
+          for (const rep of replacements) {
+            result = result.replace(rep.full, rep.varName);
+          }
+          hasChanges = true;
+        }
+      }
+      if (imports) result = imports + result;
+      if (id.endsWith(".js") && result.includes("<")) {
+        const needsReact = !result.includes("import React") && !result.includes("import * as React");
+        const withReact = needsReact ? `import React from 'react';
+${result}` : result;
+        const transformed = await (0, import_vite.transformWithOxc)(withReact, id, {
+          lang: "jsx",
+          jsx: { runtime: "classic" }
+        });
+        return { code: transformed.code, map: transformed.map };
+      }
+      if (!hasChanges) return null;
+      return { code: result, map: null };
+    }
+  };
+}
+function stubMissingNativeDeps(appDir) {
+  const checked = /* @__PURE__ */ new Map();
+  function packageExists(pkgName) {
+    const cached = checked.get(pkgName);
+    if (cached !== void 0) return cached;
+    let exists = moduleExistsIn(pkgName, sootsimRoot);
+    if (!exists && appDir) exists = moduleExistsIn(pkgName, appDir);
+    checked.set(pkgName, exists);
+    return exists;
+  }
+  return {
+    name: "sootsim-stub-missing-native-deps",
+    resolveId(source) {
+      if (!isNativePackage(source)) return null;
+      const pkgName = getPackageName(source);
+      if (packageExists(pkgName)) return null;
+      console.log(`[sootsim] auto-stubbing missing native dep: ${source}`);
+      return nativeAutoStubPath;
+    }
+  };
+}
+function stubMissingImages(isAppSource) {
+  return {
+    name: "sootsim-stub-images",
+    enforce: "pre",
+    resolveId(id, importer) {
+      if (id.endsWith(".jpg") || id.endsWith(".png") || id.endsWith(".gif")) {
+        if (importer?.includes("node_modules") || importer && isAppSource(importer)) {
+          return "\0stub-image";
+        }
+      }
+      return null;
+    },
+    load(id) {
+      if (id === "\0stub-image") return 'export default ""';
+      return null;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fixJsxRuntimeExports,
+  sootsim,
+  workerReactBridgePlugin,
+  wsBridgePlugin
+});