@ulpi/browse 2.3.2 → 2.3.4

package/dist/browse.cjs

@@ -281,7 +281,7 @@ async function getKeychainPassword(service) {
     stderr += chunk;
   });
   const exitPromise = new Promise(
-    (resolve9) => proc.on("close", (code) => resolve9(code))
+    (resolve10) => proc.on("close", (code) => resolve10(code))
   );
   const timeout = new Promise(
     (_, reject) => setTimeout(() => {
@@ -511,11 +511,11 @@ function getChromeUserDataDir() {
   return null;
 }
 function isPortFree(port) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const srv = net.createServer();
-    srv.once("error", () => resolve9(false));
+    srv.once("error", () => resolve10(false));
     srv.once("listening", () => {
-      srv.close(() => resolve9(true));
+      srv.close(() => resolve10(true));
     });
     srv.listen(port, "127.0.0.1");
   });
@@ -864,7 +864,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@ulpi/browse",
-      version: "2.3.2",
+      version: "2.3.4",
       homepage: "https://browse.ulpi.io",
       repository: {
         type: "git",
@@ -949,6 +949,19 @@ var install_skill_exports = {};
 __export(install_skill_exports, {
   installSkill: () => installSkill
 });
+function copySkillDir(srcDir, destDir, projectRoot) {
+  fs6.mkdirSync(destDir, { recursive: true });
+  for (const entry of fs6.readdirSync(srcDir, { withFileTypes: true })) {
+    const srcPath = path6.join(srcDir, entry.name);
+    const destPath = path6.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      copySkillDir(srcPath, destPath, projectRoot);
+    } else if (entry.name.endsWith(".md")) {
+      fs6.copyFileSync(srcPath, destPath);
+      console.log(`  ${path6.relative(projectRoot, destPath)}`);
+    }
+  }
+}
 function installSkill(targetDir) {
   const dir = targetDir || process.cwd();
   const hasGit = fs6.existsSync(path6.join(dir, ".git"));
@@ -958,32 +971,23 @@ function installSkill(targetDir) {
     console.error("Run from a directory with .git or .claude, or pass the path as an argument.");
     process.exit(1);
   }
-  const skillDir = path6.join(dir, ".claude", "skills", "browse");
-  fs6.mkdirSync(skillDir, { recursive: true });
-  const skillSourceDir = path6.resolve(path6.dirname((0, import_url.fileURLToPath)(__import_meta_url)), "..", "skill");
-  if (!fs6.existsSync(skillSourceDir)) {
-    console.error(`Skill directory not found at ${skillSourceDir}`);
+  const skillSourceRoot = path6.resolve(path6.dirname((0, import_url.fileURLToPath)(__import_meta_url)), "..", "skill");
+  if (!fs6.existsSync(skillSourceRoot)) {
+    console.error(`Skill directory not found at ${skillSourceRoot}`);
     console.error("Is @ulpi/browse installed correctly?");
     process.exit(1);
   }
-  const mdFiles = fs6.readdirSync(skillSourceDir).filter((f) => f.endsWith(".md"));
-  if (mdFiles.length === 0) {
-    console.error(`No .md files found in ${skillSourceDir}`);
+  const skillFolders = fs6.readdirSync(skillSourceRoot).filter(
+    (f) => fs6.statSync(path6.join(skillSourceRoot, f)).isDirectory()
+  );
+  if (skillFolders.length === 0) {
+    console.error(`No skill folders found in ${skillSourceRoot}`);
     process.exit(1);
   }
-  for (const file of mdFiles) {
-    fs6.copyFileSync(path6.join(skillSourceDir, file), path6.join(skillDir, file));
-    console.log(`Skill installed: ${path6.relative(dir, path6.join(skillDir, file))}`);
-  }
-  const refsSourceDir = path6.join(skillSourceDir, "references");
-  if (fs6.existsSync(refsSourceDir)) {
-    const refsDestDir = path6.join(skillDir, "references");
-    fs6.mkdirSync(refsDestDir, { recursive: true });
-    const refFiles = fs6.readdirSync(refsSourceDir).filter((f) => f.endsWith(".md"));
-    for (const file of refFiles) {
-      fs6.copyFileSync(path6.join(refsSourceDir, file), path6.join(refsDestDir, file));
-      console.log(`Skill installed: ${path6.relative(dir, path6.join(refsDestDir, file))}`);
-    }
+  for (const folder of skillFolders) {
+    const srcDir = path6.join(skillSourceRoot, folder);
+    const destDir = path6.join(dir, ".claude", "skills", folder);
+    copySkillDir(srcDir, destDir, dir);
   }
   const settingsPath = path6.join(dir, ".claude", "settings.json");
   let settings = {};
@@ -1080,6 +1084,356 @@ var init_install_skill = __esm({
   }
 });
 
+// src/app/ios/controller.ts
+var controller_exports = {};
+__export(controller_exports, {
+  addMedia: () => addMedia,
+  bootSimulator: () => bootSimulator,
+  checkXcodeTools: () => checkXcodeTools,
+  clearStatusBar: () => clearStatusBar,
+  getAppContainer: () => getAppContainer,
+  grantPermission: () => grantPermission,
+  installApp: () => installApp,
+  isAppInstalled: () => isAppInstalled,
+  launchApp: () => launchApp,
+  listSimulators: () => listSimulators,
+  openURL: () => openURL,
+  resetPermissions: () => resetPermissions,
+  resolveSimulator: () => resolveSimulator,
+  revokePermission: () => revokePermission,
+  screenshotSimulator: () => screenshotSimulator,
+  setStatusBar: () => setStatusBar,
+  shutdownSimulator: () => shutdownSimulator,
+  terminateApp: () => terminateApp,
+  uninstallApp: () => uninstallApp
+});
+async function simctl(...args) {
+  try {
+    const { stdout } = await execFileAsync("xcrun", ["simctl", ...args], {
+      timeout: 6e4,
+      maxBuffer: 10 * 1024 * 1024
+      // 10 MB for device list JSON
+    });
+    return stdout.trim();
+  } catch (err) {
+    const stderr = err.stderr?.trim() || "";
+    const message = stderr || err.message || "Unknown simctl error";
+    throw new Error(`simctl ${args[0]} failed: ${message}`);
+  }
+}
+async function listSimulators(filter) {
+  const raw = await simctl("list", "devices", "--json");
+  const parsed = JSON.parse(raw);
+  const results = [];
+  for (const [runtime, devices] of Object.entries(parsed.devices)) {
+    for (const device of devices) {
+      if (!device.isAvailable) continue;
+      const info = {
+        udid: device.udid,
+        name: device.name,
+        state: device.state,
+        runtime,
+        isAvailable: device.isAvailable
+      };
+      if (!filter || info.name.toLowerCase().includes(filter.toLowerCase()) || info.runtime.toLowerCase().includes(filter.toLowerCase())) {
+        results.push(info);
+      }
+    }
+  }
+  return results;
+}
+async function resolveSimulator(identifier) {
+  const all = await listSimulators();
+  if (identifier) {
+    const byUdid = all.find((s) => s.udid === identifier);
+    if (byUdid) return byUdid;
+    const byName = all.filter((s) => s.name === identifier && s.isAvailable);
+    if (byName.length === 1) return byName[0];
+    if (byName.length > 1) {
+      const booted2 = byName.find((s) => s.state === "Booted");
+      if (booted2) return booted2;
+      return byName[0];
+    }
+    const fuzzy = all.filter((s) => s.name.includes(identifier) && s.isAvailable);
+    if (fuzzy.length === 1) return fuzzy[0];
+    if (fuzzy.length > 1) return fuzzy.find((s) => s.state === "Booted") || fuzzy[0];
+    throw new Error(`Simulator '${identifier}' not found. Run: xcrun simctl list devices available`);
+  }
+  const booted = all.find((s) => s.state === "Booted");
+  if (booted) return booted;
+  if (all.length === 0) {
+    throw new Error(
+      'No iOS Simulators available. Create one with:\n  xcrun simctl create "iPhone 16 Pro" "com.apple.CoreSimulator.SimDeviceType.iPhone-16-Pro"'
+    );
+  }
+  return all[0];
+}
+async function bootSimulator(udid) {
+  const sims = await listSimulators();
+  const sim = sims.find((s) => s.udid === udid);
+  if (sim?.state === "Booted") return;
+  await simctl("boot", udid);
+  const deadline = Date.now() + 3e4;
+  while (Date.now() < deadline) {
+    const current = await listSimulators();
+    const updated = current.find((s) => s.udid === udid);
+    if (updated?.state === "Booted") return;
+    await new Promise((r2) => setTimeout(r2, 1e3));
+  }
+  throw new Error(`Simulator ${udid} did not boot within 30 seconds`);
+}
+async function shutdownSimulator(udid) {
+  await simctl("shutdown", udid);
+}
+async function installApp(udid, appPath) {
+  await simctl("install", udid, appPath);
+}
+async function uninstallApp(udid, bundleId) {
+  await simctl("uninstall", udid, bundleId);
+}
+async function launchApp(udid, bundleId, env) {
+  const args = ["launch", udid, bundleId];
+  if (env && Object.keys(env).length > 0) {
+    for (const [key, value] of Object.entries(env)) {
+      args.push(`SIMCTL_CHILD_${key}=${value}`);
+    }
+  }
+  await simctl(...args);
+}
+async function terminateApp(udid, bundleId) {
+  try {
+    await simctl("terminate", udid, bundleId);
+  } catch {
+  }
+}
+async function isAppInstalled(udid, bundleId) {
+  try {
+    await simctl("get_app_container", udid, bundleId);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function grantPermission(udid, bundleId, permission) {
+  await simctl("privacy", udid, "grant", permission, bundleId);
+}
+async function revokePermission(udid, bundleId, permission) {
+  await simctl("privacy", udid, "revoke", permission, bundleId);
+}
+async function resetPermissions(udid, bundleId) {
+  await simctl("privacy", udid, "reset", "all", bundleId);
+}
+async function screenshotSimulator(udid, outputPath) {
+  await simctl("io", udid, "screenshot", outputPath);
+}
+async function getAppContainer(udid, bundleId, container = "data") {
+  return simctl("get_app_container", udid, bundleId, container);
+}
+async function openURL(udid, url) {
+  await simctl("openurl", udid, url);
+}
+async function addMedia(udid, ...paths) {
+  await simctl("addmedia", udid, ...paths);
+}
+async function setStatusBar(udid, overrides) {
+  const args = ["status_bar", udid, "override"];
+  if (overrides.time) args.push("--time", overrides.time);
+  if (overrides.batteryLevel !== void 0) args.push("--batteryLevel", String(overrides.batteryLevel));
+  if (overrides.batteryState) args.push("--batteryState", overrides.batteryState);
+  if (overrides.cellularBars !== void 0) args.push("--cellularBars", String(overrides.cellularBars));
+  if (overrides.wifiBars !== void 0) args.push("--wifiBars", String(overrides.wifiBars));
+  if (overrides.operatorName) args.push("--operatorName", overrides.operatorName);
+  await simctl(...args);
+}
+async function clearStatusBar(udid) {
+  await simctl("status_bar", udid, "clear");
+}
+async function checkXcodeTools() {
+  try {
+    await execFileAsync("xcrun", ["--version"], { timeout: 5e3 });
+  } catch {
+    throw new Error(
+      "Xcode Command Line Tools not found.\nInstall with: xcode-select --install\nOr install Xcode from the Mac App Store."
+    );
+  }
+  try {
+    await execFileAsync("xcrun", ["simctl", "help"], { timeout: 5e3 });
+  } catch {
+    throw new Error(
+      "simctl not available. Ensure Xcode is installed and selected:\n  sudo xcode-select -s /Applications/Xcode.app"
+    );
+  }
+}
+var import_child_process3, import_util, execFileAsync;
+var init_controller = __esm({
+  "src/app/ios/controller.ts"() {
+    "use strict";
+    import_child_process3 = require("child_process");
+    import_util = require("util");
+    execFileAsync = (0, import_util.promisify)(import_child_process3.execFile);
+  }
+});
+
+// src/app/resolve-app.ts
+var resolve_app_exports = {};
+__export(resolve_app_exports, {
+  isAppFilePath: () => isAppFilePath,
+  resolveAndroidApp: () => resolveAndroidApp,
+  resolveIOSApp: () => resolveIOSApp
+});
+function isAppFilePath(value) {
+  const lower = value.toLowerCase();
+  if (lower.endsWith(".ipa") || lower.endsWith(".apk")) return true;
+  if (lower.endsWith(".app") && fs7.existsSync(value)) return true;
+  return false;
+}
+async function resolveIOSApp(appArg, udid, log2) {
+  if (!isAppFilePath(appArg)) return appArg;
+  const absPath = path7.resolve(appArg);
+  if (appArg.toLowerCase().endsWith(".ipa")) {
+    return resolveIPA(absPath, udid, log2);
+  }
+  if (!fs7.existsSync(absPath)) {
+    throw new Error(`App bundle not found: ${absPath}`);
+  }
+  const bundleId = extractBundleId(absPath);
+  log2(`Installing ${path7.basename(absPath)} (${bundleId})...`);
+  const { installApp: installApp2 } = await Promise.resolve().then(() => (init_controller(), controller_exports));
+  await installApp2(udid, absPath);
+  return bundleId;
+}
+function extractBundleId(appPath) {
+  const plistPath = path7.join(appPath, "Info.plist");
+  if (!fs7.existsSync(plistPath)) {
+    throw new Error(`Info.plist not found in ${appPath}. Is this a valid iOS app bundle?`);
+  }
+  try {
+    const json = (0, import_child_process4.execSync)(`plutil -convert json -o - "${plistPath}"`, {
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    const parsed = JSON.parse(json);
+    const bundleId = parsed.CFBundleIdentifier;
+    if (!bundleId) {
+      throw new Error(`CFBundleIdentifier not found in ${plistPath}`);
+    }
+    return bundleId;
+  } catch (err) {
+    if (err.message?.includes("CFBundleIdentifier")) throw err;
+    throw new Error(`Failed to read bundle ID from ${plistPath}: ${err.message}`);
+  }
+}
+async function resolveIPA(ipaPath, udid, log2) {
+  if (!fs7.existsSync(ipaPath)) {
+    throw new Error(`IPA file not found: ${ipaPath}`);
+  }
+  const tmpDir = fs7.mkdtempSync(path7.join(os3.tmpdir(), "browse-ipa-"));
+  try {
+    (0, import_child_process4.execSync)(`unzip -o -q "${ipaPath}" -d "${tmpDir}"`, { timeout: 3e4 });
+    const payloadDir = path7.join(tmpDir, "Payload");
+    if (!fs7.existsSync(payloadDir)) {
+      throw new Error(`No Payload directory in ${ipaPath}. Is this a valid .ipa file?`);
+    }
+    const appDirs = fs7.readdirSync(payloadDir).filter((f) => f.endsWith(".app"));
+    if (appDirs.length === 0) {
+      throw new Error(`No .app bundle found in ${ipaPath}/Payload/`);
+    }
+    const appPath = path7.join(payloadDir, appDirs[0]);
+    const bundleId = extractBundleId(appPath);
+    log2(`Installing ${appDirs[0]} (${bundleId}) from IPA...`);
+    const { installApp: installApp2 } = await Promise.resolve().then(() => (init_controller(), controller_exports));
+    await installApp2(udid, appPath);
+    return bundleId;
+  } finally {
+    try {
+      fs7.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+async function resolveAndroidApp(appArg, serial, log2) {
+  if (!isAppFilePath(appArg)) return appArg;
+  const absPath = path7.resolve(appArg);
+  if (!fs7.existsSync(absPath)) {
+    throw new Error(`APK file not found: ${absPath}`);
+  }
+  const packageName = extractPackageName(absPath);
+  log2(`Installing ${path7.basename(absPath)} (${packageName})...`);
+  try {
+    (0, import_child_process4.execSync)(`adb -s ${serial} install -r -t "${absPath}"`, {
+      stdio: "pipe",
+      timeout: 6e4
+    });
+  } catch (err) {
+    throw new Error(`Failed to install APK: ${err.message?.split("\n")[0]}`);
+  }
+  return packageName;
+}
+function extractPackageName(apkPath) {
+  const aaptBins = findAaptBinaries();
+  for (const aapt of aaptBins) {
+    try {
+      const output = (0, import_child_process4.execSync)(`"${aapt}" dump badging "${apkPath}"`, {
+        encoding: "utf-8",
+        timeout: 1e4,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const match = output.match(/package:\s*name='([^']+)'/);
+      if (match) return match[1];
+    } catch {
+      continue;
+    }
+  }
+  throw new Error(
+    `Cannot determine package name from ${path7.basename(apkPath)}.
+Install Android build-tools (browse enable android) or provide the package name directly:
+  browse sim start --platform android --app com.example.myapp`
+  );
+}
+function findAaptBinaries() {
+  const bins = [];
+  try {
+    (0, import_child_process4.execSync)("which aapt2", { stdio: "pipe", timeout: 3e3 });
+    bins.push("aapt2");
+  } catch {
+  }
+  try {
+    (0, import_child_process4.execSync)("which aapt", { stdio: "pipe", timeout: 3e3 });
+    bins.push("aapt");
+  } catch {
+  }
+  const sdkRoots = [
+    process.env.ANDROID_HOME,
+    process.env.ANDROID_SDK_ROOT,
+    path7.join(os3.homedir(), "Library/Android/sdk"),
+    "/opt/homebrew/share/android-commandlinetools",
+    path7.join(os3.homedir(), "Android/Sdk")
+  ].filter(Boolean);
+  for (const sdk of sdkRoots) {
+    const btDir = path7.join(sdk, "build-tools");
+    if (!fs7.existsSync(btDir)) continue;
+    const versions = fs7.readdirSync(btDir).sort().reverse();
+    for (const ver of versions) {
+      const aapt2 = path7.join(btDir, ver, "aapt2");
+      const aapt = path7.join(btDir, ver, "aapt");
+      if (fs7.existsSync(aapt2)) bins.push(aapt2);
+      if (fs7.existsSync(aapt)) bins.push(aapt);
+      break;
+    }
+  }
+  return bins;
+}
+var import_child_process4, fs7, path7, os3;
+var init_resolve_app = __esm({
+  "src/app/resolve-app.ts"() {
+    "use strict";
+    import_child_process4 = require("child_process");
+    fs7 = __toESM(require("fs"), 1);
+    path7 = __toESM(require("path"), 1);
+    os3 = __toESM(require("os"), 1);
+  }
+});
+
 // src/app/android/bridge.ts
 var bridge_exports = {};
 __export(bridge_exports, {
@@ -1091,41 +1445,41 @@ __export(bridge_exports, {
 function resolveDriverApkPath() {
   const candidates = [
     // 1. Local dev build
-    path7.resolve(__dirname2, "../../../browse-android/app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk"),
+    path8.resolve(__dirname2, "../../../browse-android/app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk"),
     // 2. Installed alongside source (bin/ at project root)
-    path7.resolve(__dirname2, "../../bin/browse-android.apk"),
+    path8.resolve(__dirname2, "../../bin/browse-android.apk"),
     // 3. Bundled build (dist/browse.cjs → ../bin/)
-    path7.resolve(__dirname2, "../bin/browse-android.apk"),
+    path8.resolve(__dirname2, "../bin/browse-android.apk"),
     // 4. Same directory as binary
-    path7.resolve(__dirname2, "browse-android.apk")
+    path8.resolve(__dirname2, "browse-android.apk")
   ];
   for (const p of candidates) {
-    if (fs7.existsSync(p)) return p;
+    if (fs8.existsSync(p)) return p;
   }
-  const lazyPath = path7.join(
-    process.env.BROWSE_LOCAL_DIR || path7.join(process.cwd(), ".browse"),
+  const lazyPath = path8.join(
+    process.env.BROWSE_LOCAL_DIR || path8.join(process.cwd(), ".browse"),
     "bin",
     "browse-android.apk"
   );
-  if (fs7.existsSync(lazyPath)) return lazyPath;
+  if (fs8.existsSync(lazyPath)) return lazyPath;
   throw new Error(
     "browse-android APK not found. Run: browse enable android\nOr build manually: cd browse-android && ./gradlew :app:assembleDebugAndroidTest"
   );
 }
 function resolveAppApkPath() {
   const candidates = [
-    path7.resolve(__dirname2, "../../../browse-android/app/build/outputs/apk/debug/app-debug.apk"),
-    path7.resolve(__dirname2, "../../bin/browse-android-app.apk"),
-    path7.resolve(__dirname2, "../bin/browse-android-app.apk"),
-    path7.resolve(__dirname2, "browse-android-app.apk")
+    path8.resolve(__dirname2, "../../../browse-android/app/build/outputs/apk/debug/app-debug.apk"),
+    path8.resolve(__dirname2, "../../bin/browse-android-app.apk"),
+    path8.resolve(__dirname2, "../bin/browse-android-app.apk"),
+    path8.resolve(__dirname2, "browse-android-app.apk")
   ];
   for (const p of candidates) {
-    if (fs7.existsSync(p)) return p;
+    if (fs8.existsSync(p)) return p;
   }
   return null;
 }
 function adbExec(serial, ...args) {
-  return (0, import_child_process3.execSync)(["adb", "-s", serial, ...args].join(" "), {
+  return (0, import_child_process5.execSync)(["adb", "-s", serial, ...args].join(" "), {
     encoding: "utf-8",
     timeout: 3e4,
     stdio: ["ignore", "pipe", "pipe"]
@@ -1140,7 +1494,7 @@ function adbExecSafe(serial, ...args) {
 }
 async function ensureAndroidBridge(serial) {
   try {
-    (0, import_child_process3.execSync)("adb version", { stdio: "ignore", timeout: 5e3 });
+    (0, import_child_process5.execSync)("adb version", { stdio: "ignore", timeout: 5e3 });
   } catch {
     throw new AdbNotFoundError();
   }
@@ -1151,7 +1505,7 @@ async function installAdb(log2) {
 `));
   if (process.platform === "darwin") {
     try {
-      (0, import_child_process3.execSync)("brew --version", { stdio: "ignore", timeout: 5e3 });
+      (0, import_child_process5.execSync)("brew --version", { stdio: "ignore", timeout: 5e3 });
     } catch {
       print("Homebrew not found. Install it first: https://brew.sh");
       print("Then run: brew install android-platform-tools");
@@ -1159,11 +1513,11 @@ async function installAdb(log2) {
     }
     print("Installing Android platform-tools via Homebrew...");
     try {
-      (0, import_child_process3.execSync)("brew install android-platform-tools", {
+      (0, import_child_process5.execSync)("brew install android-platform-tools", {
         stdio: ["ignore", "pipe", "pipe"],
         timeout: 12e4
       });
-      (0, import_child_process3.execSync)("adb version", { stdio: "ignore", timeout: 5e3 });
+      (0, import_child_process5.execSync)("adb version", { stdio: "ignore", timeout: 5e3 });
       print("adb installed successfully.");
       return true;
     } catch (err) {
@@ -1178,7 +1532,7 @@ async function installAdb(log2) {
   return false;
 }
 function resolveDevice(serial) {
-  const output = (0, import_child_process3.execSync)("adb devices", { encoding: "utf-8", timeout: 5e3 });
+  const output = (0, import_child_process5.execSync)("adb devices", { encoding: "utf-8", timeout: 5e3 });
   const lines = output.split("\n").slice(1).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("*"));
   const booted = lines.filter((l) => l.endsWith("	device")).map((l) => l.split("	")[0].trim());
   if (booted.length === 0) {
@@ -1245,7 +1599,7 @@ Install it first, e.g.: adb -s ${serial} install path/to/app.apk`
 }
 function installDriverApk(serial, apkPath) {
   try {
-    const stat = fs7.statSync(apkPath);
+    const stat = fs8.statSync(apkPath);
     if (stat.size < 1024) {
       throw new Error(`APK file appears corrupt (${stat.size} bytes): ${apkPath}`);
     }
@@ -1261,7 +1615,7 @@ function installDriverApk(serial, apkPath) {
     return;
   }
   const appApkPath = resolveAppApkPath() || apkPath.replace("-androidTest", "");
-  if (fs7.existsSync(appApkPath)) {
+  if (fs8.existsSync(appApkPath)) {
     try {
       adbExec(serial, "install", "-t", "-r", `"${appApkPath}"`);
     } catch {
@@ -1284,7 +1638,7 @@ function killStaleInstrumentation(serial) {
   adbExecSafe(serial, "shell", "am", "force-stop", DRIVER_PACKAGE);
 }
 function startInstrumentation(serial, targetPackage) {
-  const proc = (0, import_child_process3.spawn)(
+  const proc = (0, import_child_process5.spawn)(
     "adb",
     [
       "-s",
@@ -1396,16 +1750,16 @@ function buildProtocol(serial, port) {
     }
   };
 }
-var import_child_process3, fs7, path7, import_url2, __filename_bridge, __dirname2, DRIVER_PACKAGE, DRIVER_TEST_PACKAGE, DRIVER_RUNNER, DRIVER_PORT, DRIVER_HEALTH_TIMEOUT_MS, DRIVER_HEALTH_POLL_MS, INSTRUMENTATION_MAX_RETRIES, AdbNotFoundError;
+var import_child_process5, fs8, path8, import_url2, __filename_bridge, __dirname2, DRIVER_PACKAGE, DRIVER_TEST_PACKAGE, DRIVER_RUNNER, DRIVER_PORT, DRIVER_HEALTH_TIMEOUT_MS, DRIVER_HEALTH_POLL_MS, INSTRUMENTATION_MAX_RETRIES, AdbNotFoundError;
 var init_bridge = __esm({
   "src/app/android/bridge.ts"() {
     "use strict";
-    import_child_process3 = require("child_process");
-    fs7 = __toESM(require("fs"), 1);
-    path7 = __toESM(require("path"), 1);
+    import_child_process5 = require("child_process");
+    fs8 = __toESM(require("fs"), 1);
+    path8 = __toESM(require("path"), 1);
     import_url2 = require("url");
     __filename_bridge = (0, import_url2.fileURLToPath)(__import_meta_url);
-    __dirname2 = path7.dirname(__filename_bridge);
+    __dirname2 = path8.dirname(__filename_bridge);
     DRIVER_PACKAGE = "io.ulpi.browse.driver";
     DRIVER_TEST_PACKAGE = `${DRIVER_PACKAGE}.test`;
     DRIVER_RUNNER = "androidx.test.runner.AndroidJUnitRunner";
@@ -1445,7 +1799,7 @@ function ensureJavaHome() {
     "/usr/local/opt/openjdk/libexec/openjdk.jdk/Contents/Home"
   ];
   for (const jdk of candidates) {
-    if (fs8.existsSync(jdk)) {
+    if (fs9.existsSync(jdk)) {
       process.env.JAVA_HOME = jdk;
       process.env.PATH = `${jdk}/bin:${process.env.PATH}`;
       return;
@@ -1458,20 +1812,20 @@ function sdkCandidates() {
     return [
       process.env.ANDROID_HOME || "",
       process.env.ANDROID_SDK_ROOT || "",
-      path8.join(home, "Library/Android/sdk"),
+      path9.join(home, "Library/Android/sdk"),
       "/opt/homebrew/share/android-commandlinetools"
     ].filter(Boolean);
   }
   return [
     process.env.ANDROID_HOME || "",
     process.env.ANDROID_SDK_ROOT || "",
-    path8.join(home, "Android/Sdk"),
+    path9.join(home, "Android/Sdk"),
     "/usr/lib/android-sdk"
   ].filter(Boolean);
 }
 function findSdkRoot() {
   for (const dir of sdkCandidates()) {
-    if (fs8.existsSync(path8.join(dir, "cmdline-tools")) || fs8.existsSync(path8.join(dir, "platform-tools")) || fs8.existsSync(path8.join(dir, "emulator"))) {
+    if (fs9.existsSync(path9.join(dir, "cmdline-tools")) || fs9.existsSync(path9.join(dir, "platform-tools")) || fs9.existsSync(path9.join(dir, "emulator"))) {
       return dir;
     }
   }
@@ -1479,37 +1833,37 @@ function findSdkRoot() {
 }
 function findSdkManager(sdkRoot) {
   const paths = [
-    path8.join(sdkRoot, "cmdline-tools/latest/bin/sdkmanager"),
-    path8.join(sdkRoot, "cmdline-tools/bin/sdkmanager"),
+    path9.join(sdkRoot, "cmdline-tools/latest/bin/sdkmanager"),
+    path9.join(sdkRoot, "cmdline-tools/bin/sdkmanager"),
     // Homebrew installs cmdline-tools directly
-    path8.join(sdkRoot, "bin/sdkmanager")
+    path9.join(sdkRoot, "bin/sdkmanager")
   ];
   for (const p of paths) {
-    if (fs8.existsSync(p)) return p;
+    if (fs9.existsSync(p)) return p;
   }
   return null;
 }
 function findAvdManager(sdkRoot) {
   const paths = [
-    path8.join(sdkRoot, "cmdline-tools/latest/bin/avdmanager"),
-    path8.join(sdkRoot, "cmdline-tools/bin/avdmanager"),
-    path8.join(sdkRoot, "bin/avdmanager")
+    path9.join(sdkRoot, "cmdline-tools/latest/bin/avdmanager"),
+    path9.join(sdkRoot, "cmdline-tools/bin/avdmanager"),
+    path9.join(sdkRoot, "bin/avdmanager")
   ];
   for (const p of paths) {
-    if (fs8.existsSync(p)) return p;
+    if (fs9.existsSync(p)) return p;
   }
   return null;
 }
 function findEmulator(sdkRoot) {
   const paths = [
-    path8.join(sdkRoot, "emulator/emulator"),
-    path8.join(sdkRoot, "tools/emulator")
+    path9.join(sdkRoot, "emulator/emulator"),
+    path9.join(sdkRoot, "tools/emulator")
   ];
   for (const p of paths) {
-    if (fs8.existsSync(p)) return p;
+    if (fs9.existsSync(p)) return p;
   }
   try {
-    (0, import_child_process4.execSync)("which emulator", { stdio: "pipe", timeout: 3e3 });
+    (0, import_child_process6.execSync)("which emulator", { stdio: "pipe", timeout: 3e3 });
     return "emulator";
   } catch {
     return null;
@@ -1518,7 +1872,7 @@ function findEmulator(sdkRoot) {
 async function installSdk(log2) {
   if (process.platform === "darwin") {
     try {
-      (0, import_child_process4.execSync)("brew --version", { stdio: "ignore", timeout: 5e3 });
+      (0, import_child_process6.execSync)("brew --version", { stdio: "ignore", timeout: 5e3 });
     } catch {
       log2("Homebrew not found. Install Android Studio manually:");
       log2("  https://developer.android.com/studio");
@@ -1526,7 +1880,7 @@ async function installSdk(log2) {
     }
     log2("Installing Android SDK command-line tools via Homebrew...");
     try {
-      (0, import_child_process4.execSync)("brew install --cask android-commandlinetools", {
+      (0, import_child_process6.execSync)("brew install --cask android-commandlinetools", {
         stdio: ["ignore", "pipe", "pipe"],
         timeout: 3e5
       });
@@ -1549,13 +1903,13 @@ async function installSdk(log2) {
   return null;
 }
 function hasSystemImage(sdkRoot) {
-  const imgDir = path8.join(sdkRoot, "system-images", `android-${DEFAULT_API_LEVEL}`, "google_apis", "arm64-v8a");
-  return fs8.existsSync(imgDir);
+  const imgDir = path9.join(sdkRoot, "system-images", `android-${DEFAULT_API_LEVEL}`, "google_apis", "arm64-v8a");
+  return fs9.existsSync(imgDir);
 }
 function installSystemImage(sdkManager, log2) {
   log2(`Installing system image (API ${DEFAULT_API_LEVEL})... this may take a few minutes`);
   try {
-    (0, import_child_process4.execSync)(`yes | "${sdkManager}" --install "${DEFAULT_SYSTEM_IMAGE}"`, {
+    (0, import_child_process6.execSync)(`yes | "${sdkManager}" --install "${DEFAULT_SYSTEM_IMAGE}"`, {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 6e5,
       shell: "/bin/bash"
@@ -1569,7 +1923,7 @@ function installSystemImage(sdkManager, log2) {
 }
 function listAvds(avdManager) {
   try {
-    const output = (0, import_child_process4.execSync)(`"${avdManager}" list avd -c`, {
+    const output = (0, import_child_process6.execSync)(`"${avdManager}" list avd -c`, {
       encoding: "utf-8",
       timeout: 1e4,
       stdio: ["ignore", "pipe", "pipe"]
@@ -1582,7 +1936,7 @@ function listAvds(avdManager) {
 function createAvd(sdkRoot, avdManager, log2) {
   log2(`Creating AVD '${DEFAULT_AVD_NAME}'...`);
   try {
-    (0, import_child_process4.execSync)(
+    (0, import_child_process6.execSync)(
       `echo no | "${avdManager}" create avd -n ${DEFAULT_AVD_NAME} -k "${DEFAULT_SYSTEM_IMAGE}" --force`,
       { stdio: ["pipe", "pipe", "pipe"], timeout: 3e4, shell: "/bin/bash" }
     );
@@ -1596,7 +1950,7 @@ function startEmulator(emulatorBin, avdName, log2, visible = false) {
   log2(`Starting emulator '${avdName}'${visible ? "" : " (headless)"}...`);
   const emulatorArgs = ["-avd", avdName, "-no-audio", "-gpu", "swiftshader_indirect"];
   if (!visible) emulatorArgs.push("-no-window");
-  const proc = (0, import_child_process4.spawn)(emulatorBin, emulatorArgs, {
+  const proc = (0, import_child_process6.spawn)(emulatorBin, emulatorArgs, {
     stdio: "ignore",
     detached: true
   });
@@ -1607,13 +1961,13 @@ async function waitForBoot(log2, timeoutMs = 12e4) {
   log2("Waiting for emulator to boot...");
   while (Date.now() < deadline) {
     try {
-      const output = (0, import_child_process4.execSync)("adb devices", { encoding: "utf-8", timeout: 5e3 });
+      const output = (0, import_child_process6.execSync)("adb devices", { encoding: "utf-8", timeout: 5e3 });
       const lines = output.split("\n").slice(1).filter((l) => l.includes("	device"));
       const emulator = lines.find((l) => l.startsWith("emulator-"));
       if (emulator) {
         const serial = emulator.split("	")[0].trim();
         try {
-          const bootAnim = (0, import_child_process4.execSync)(`adb -s ${serial} shell getprop init.svc.bootanim`, {
+          const bootAnim = (0, import_child_process6.execSync)(`adb -s ${serial} shell getprop init.svc.bootanim`, {
             encoding: "utf-8",
             timeout: 5e3
           }).trim();
@@ -1633,7 +1987,7 @@ async function ensureEmulator(log2, visible = false) {
   ensureJavaHome();
   const hasJava = () => {
     try {
-      (0, import_child_process4.execSync)("java -version", { stdio: "ignore", timeout: 5e3 });
+      (0, import_child_process6.execSync)("java -version", { stdio: "ignore", timeout: 5e3 });
       return true;
     } catch {
       return false;
@@ -1642,7 +1996,7 @@ async function ensureEmulator(log2, visible = false) {
   if (!hasJava()) {
     if (process.platform === "darwin") {
       try {
-        (0, import_child_process4.execSync)("brew --version", { stdio: "ignore", timeout: 5e3 });
+        (0, import_child_process6.execSync)("brew --version", { stdio: "ignore", timeout: 5e3 });
       } catch {
         throw new Error("Java is required for Android SDK.\nInstall Homebrew (https://brew.sh) then: brew install --cask temurin");
       }
@@ -1651,7 +2005,7 @@ async function ensureEmulator(log2, visible = false) {
       for (const formula of javaFormulas) {
         try {
           const cmd = formula === "openjdk" ? `brew install ${formula}` : `brew install --cask ${formula}`;
-          (0, import_child_process4.execSync)(cmd, { stdio: ["ignore", "pipe", "pipe"], timeout: 3e5 });
+          (0, import_child_process6.execSync)(cmd, { stdio: ["ignore", "pipe", "pipe"], timeout: 3e5 });
         } catch {
         }
         if (formula.startsWith("openjdk")) {
@@ -1682,7 +2036,7 @@ async function ensureEmulator(log2, visible = false) {
   const avdManager = findAvdManager(sdkRoot);
   if (sdkManager) {
     try {
-      (0, import_child_process4.execSync)(`yes | "${sdkManager}" --licenses`, {
+      (0, import_child_process6.execSync)(`yes | "${sdkManager}" --licenses`, {
         stdio: ["pipe", "pipe", "pipe"],
         timeout: 6e4,
         shell: "/bin/bash"
@@ -1693,7 +2047,7 @@ async function ensureEmulator(log2, visible = false) {
   if (!emulatorBin && sdkManager) {
     log2("Installing Android emulator and build tools...");
     try {
-      (0, import_child_process4.execSync)(
+      (0, import_child_process6.execSync)(
         `"${sdkManager}" --install "emulator" "platform-tools" "platforms;android-${DEFAULT_API_LEVEL}" "build-tools;${DEFAULT_API_LEVEL}.0.0"`,
         { stdio: ["pipe", "pipe", "pipe"], timeout: 3e5 }
       );
@@ -1725,13 +2079,13 @@ async function ensureEmulator(log2, visible = false) {
   startEmulator(emulatorBin, DEFAULT_AVD_NAME, log2, visible);
   return waitForBoot(log2);
 }
-var import_child_process4, fs8, path8, DEFAULT_AVD_NAME, DEFAULT_API_LEVEL, DEFAULT_SYSTEM_IMAGE;
+var import_child_process6, fs9, path9, DEFAULT_AVD_NAME, DEFAULT_API_LEVEL, DEFAULT_SYSTEM_IMAGE;
 var init_emulator = __esm({
   "src/app/android/emulator.ts"() {
     "use strict";
-    import_child_process4 = require("child_process");
-    fs8 = __toESM(require("fs"), 1);
-    path8 = __toESM(require("path"), 1);
+    import_child_process6 = require("child_process");
+    fs9 = __toESM(require("fs"), 1);
+    path9 = __toESM(require("path"), 1);
     DEFAULT_AVD_NAME = "browse_default";
     DEFAULT_API_LEVEL = "35";
     DEFAULT_SYSTEM_IMAGE = `system-images;android-${DEFAULT_API_LEVEL};google_apis;arm64-v8a`;
@@ -1753,396 +2107,217 @@ function resolveStateDir() {
   if (localDir) return localDir;
   let dir = process.cwd();
   for (let i = 0; i < 20; i++) {
-    if (fs9.existsSync(path9.join(dir, ".git")) || fs9.existsSync(path9.join(dir, ".claude"))) {
-      const browseDir = path9.join(dir, ".browse");
-      fs9.mkdirSync(browseDir, { recursive: true });
+    if (fs10.existsSync(path10.join(dir, ".git")) || fs10.existsSync(path10.join(dir, ".claude"))) {
+      const browseDir = path10.join(dir, ".browse");
+      fs10.mkdirSync(browseDir, { recursive: true });
       return browseDir;
     }
-    const parent = path9.dirname(dir);
+    const parent = path10.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return "/tmp";
 }
 function stateFilePath() {
-  return path9.join(resolveStateDir(), "android-state.json");
+  return path10.join(resolveStateDir(), "android-state.json");
 }
 function readState() {
   try {
-    return JSON.parse(fs9.readFileSync(stateFilePath(), "utf-8"));
+    return JSON.parse(fs10.readFileSync(stateFilePath(), "utf-8"));
   } catch {
     return null;
   }
 }
 function writeState(state) {
-  const dir = path9.dirname(stateFilePath());
-  fs9.mkdirSync(dir, { recursive: true });
-  fs9.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
-}
-function clearState() {
-  try {
-    fs9.unlinkSync(stateFilePath());
-  } catch {
-  }
-}
-async function checkHealth(port = DRIVER_PORT2) {
-  try {
-    const resp = await fetch(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(2e3) });
-    return resp.ok;
-  } catch {
-    return false;
-  }
-}
-async function status() {
-  const state = readState();
-  if (!state) return { running: false, state: null, healthy: false };
-  const healthy = await checkHealth(state.port);
-  if (!healthy) {
-    clearState();
-    return { running: false, state, healthy: false };
-  }
-  return { running: true, state, healthy: true };
-}
-async function stopDriver() {
-  const state = readState();
-  if (!state) return;
-  try {
-    (0, import_child_process5.execSync)(`adb -s ${state.serial} shell am force-stop io.ulpi.browse.driver.test`, { stdio: "pipe", timeout: 5e3 });
-    (0, import_child_process5.execSync)(`adb -s ${state.serial} shell am force-stop io.ulpi.browse.driver`, { stdio: "pipe", timeout: 5e3 });
-    (0, import_child_process5.execSync)(`adb -s ${state.serial} forward --remove tcp:${state.port}`, { stdio: "pipe", timeout: 5e3 });
-  } catch {
-  }
-  clearState();
-}
-async function stop() {
-  const state = readState();
-  if (!state) return "No Android device/emulator running.";
-  try {
-    (0, import_child_process5.execSync)(`adb -s ${state.serial} shell am force-stop io.ulpi.browse.driver.test`, { stdio: "pipe", timeout: 5e3 });
-    (0, import_child_process5.execSync)(`adb -s ${state.serial} shell am force-stop io.ulpi.browse.driver`, { stdio: "pipe", timeout: 5e3 });
-    (0, import_child_process5.execSync)(`adb -s ${state.serial} forward --remove tcp:${state.port}`, { stdio: "pipe", timeout: 5e3 });
-    if (state.serial.startsWith("emulator-")) {
-      (0, import_child_process5.execSync)(`adb -s ${state.serial} emu kill`, { stdio: "pipe", timeout: 1e4 });
-    }
-  } catch {
-  }
-  clearState();
-  return `Android stopped (${state.device}).`;
-}
-async function startAndroid(opts = {}) {
-  const log2 = opts.log || ((msg) => process.stderr.write(`[browse] ${msg}
-`));
-  const port = DRIVER_PORT2;
-  const existing = readState();
-  if (existing) {
-    const healthy = await checkHealth(existing.port);
-    if (healthy) {
-      if (opts.app && existing.app !== opts.app) {
-        log2(`Switching to ${opts.app}...`);
-        await stopDriver();
-      } else {
-        return existing;
-      }
-    }
-    log2("Cleaning up stale driver...");
-    await stopDriver();
-  }
-  log2("Finding Android device...");
-  const { ensureAndroidBridge: ensureAndroidBridge2, createAndroidBridge: createAndroidBridge2, AdbNotFoundError: AdbNotFoundError2, installAdb: installAdb2 } = await Promise.resolve().then(() => (init_bridge(), bridge_exports));
-  let serial;
-  try {
-    serial = await ensureAndroidBridge2(opts.device);
-  } catch (err) {
-    if (err instanceof AdbNotFoundError2) {
-      log2("adb not found. Attempting to install...");
-      const installed = await installAdb2(log2);
-      if (!installed) throw err;
-      try {
-        serial = await ensureAndroidBridge2(opts.device);
-      } catch (retryErr) {
-        if (retryErr.message?.includes("No booted Android device")) {
-          const { ensureEmulator: ensureEmulator2 } = await Promise.resolve().then(() => (init_emulator(), emulator_exports));
-          serial = await ensureEmulator2(log2, opts.visible);
-        } else {
-          throw retryErr;
-        }
-      }
-    } else if (err.message?.includes("No booted Android device")) {
-      const { ensureEmulator: ensureEmulator2 } = await Promise.resolve().then(() => (init_emulator(), emulator_exports));
-      serial = await ensureEmulator2(log2, opts.visible);
-    } else {
-      throw err;
-    }
-  }
-  let deviceName = serial;
-  try {
-    deviceName = (0, import_child_process5.execSync)(`adb -s ${serial} shell getprop ro.product.model`, {
-      encoding: "utf-8",
-      timeout: 5e3,
-      stdio: ["ignore", "pipe", "pipe"]
-    }).trim() || serial;
-  } catch {
-  }
-  const driverApkDir = path9.resolve(__dirname3, "../../../browse-android");
-  const apkPath = path9.join(driverApkDir, "app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk");
-  if (!fs9.existsSync(apkPath) && fs9.existsSync(path9.join(driverApkDir, "gradlew"))) {
-    log2("Building Android driver APK...");
-    try {
-      const { findSdkRoot: findSdkRoot2, ensureJavaHome: ensureJavaHome2 } = await Promise.resolve().then(() => (init_emulator(), emulator_exports));
-      ensureJavaHome2();
-      if (!process.env.ANDROID_HOME) {
-        const sdkRoot = findSdkRoot2();
-        if (sdkRoot) process.env.ANDROID_HOME = sdkRoot;
-      }
-      (0, import_child_process5.execSync)("./gradlew :app:assembleDebug :app:assembleDebugAndroidTest --stacktrace", {
-        cwd: driverApkDir,
-        stdio: ["ignore", "pipe", "pipe"],
-        timeout: 3e5
-      });
-      log2("APK built.");
-    } catch (err) {
-      const stdout = err.stdout?.toString() || "";
-      const stderr = err.stderr?.toString() || "";
-      const combined = stdout + "\n" + stderr;
-      const lines = combined.split("\n");
-      const errorLines = lines.filter(
-        (l) => !l.startsWith("	at ") && !l.startsWith("	at ") && (l.includes("error") || l.includes("Error") || l.includes("FAILURE") || l.includes("Could not") || l.includes("wrong") || l.includes("Cannot") || l.includes("SDK") || l.includes("missing"))
-      );
-      log2(`APK build failed:
-${errorLines.slice(0, 10).join("\n") || lines.slice(0, 15).join("\n")}`);
-    }
-  }
-  const targetApp = opts.app || "com.android.settings";
-  log2(`Launching ${targetApp}...`);
-  try {
-    (0, import_child_process5.execSync)(`adb -s ${serial} shell am start -a android.intent.action.MAIN -c android.intent.category.LAUNCHER -p ${targetApp}`, {
-      stdio: "pipe",
-      timeout: 1e4
-    });
-  } catch {
-    try {
-      (0, import_child_process5.execSync)(`adb -s ${serial} shell monkey -p ${targetApp} -c android.intent.category.LAUNCHER 1`, {
-        stdio: "pipe",
-        timeout: 1e4
-      });
-    } catch {
-    }
-  }
-  await sleep(2e3);
-  log2("Starting driver...");
-  await createAndroidBridge2(serial, targetApp);
-  const state = {
-    platform: "android",
-    device: deviceName,
-    serial,
-    app: targetApp,
-    port,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  writeState(state);
-  return state;
-}
-var fs9, path9, import_child_process5, import_url3, __dirname3, DRIVER_PORT2, sleep;
-var init_sim_service = __esm({
-  "src/app/android/sim-service.ts"() {
-    "use strict";
-    fs9 = __toESM(require("fs"), 1);
-    path9 = __toESM(require("path"), 1);
-    import_child_process5 = require("child_process");
-    import_url3 = require("url");
-    __dirname3 = path9.dirname((0, import_url3.fileURLToPath)(__import_meta_url));
-    DRIVER_PORT2 = 7779;
-    sleep = (ms) => new Promise((r2) => setTimeout(r2, ms));
-  }
-});
-
-// src/app/ios/controller.ts
-var controller_exports = {};
-__export(controller_exports, {
-  addMedia: () => addMedia,
-  bootSimulator: () => bootSimulator,
-  checkXcodeTools: () => checkXcodeTools,
-  clearStatusBar: () => clearStatusBar,
-  getAppContainer: () => getAppContainer,
-  grantPermission: () => grantPermission,
-  installApp: () => installApp,
-  isAppInstalled: () => isAppInstalled,
-  launchApp: () => launchApp,
-  listSimulators: () => listSimulators,
-  openURL: () => openURL,
-  resetPermissions: () => resetPermissions,
-  resolveSimulator: () => resolveSimulator,
-  revokePermission: () => revokePermission,
-  screenshotSimulator: () => screenshotSimulator,
-  setStatusBar: () => setStatusBar,
-  shutdownSimulator: () => shutdownSimulator,
-  terminateApp: () => terminateApp,
-  uninstallApp: () => uninstallApp
-});
-async function simctl(...args) {
-  try {
-    const { stdout } = await execFileAsync("xcrun", ["simctl", ...args], {
-      timeout: 6e4,
-      maxBuffer: 10 * 1024 * 1024
-      // 10 MB for device list JSON
-    });
-    return stdout.trim();
-  } catch (err) {
-    const stderr = err.stderr?.trim() || "";
-    const message = stderr || err.message || "Unknown simctl error";
-    throw new Error(`simctl ${args[0]} failed: ${message}`);
-  }
-}
-async function listSimulators(filter) {
-  const raw = await simctl("list", "devices", "--json");
-  const parsed = JSON.parse(raw);
-  const results = [];
-  for (const [runtime, devices] of Object.entries(parsed.devices)) {
-    for (const device of devices) {
-      if (!device.isAvailable) continue;
-      const info = {
-        udid: device.udid,
-        name: device.name,
-        state: device.state,
-        runtime,
-        isAvailable: device.isAvailable
-      };
-      if (!filter || info.name.toLowerCase().includes(filter.toLowerCase()) || info.runtime.toLowerCase().includes(filter.toLowerCase())) {
-        results.push(info);
-      }
-    }
-  }
-  return results;
-}
-async function resolveSimulator(identifier) {
-  const all = await listSimulators();
-  if (identifier) {
-    const byUdid = all.find((s) => s.udid === identifier);
-    if (byUdid) return byUdid;
-    const byName = all.filter((s) => s.name === identifier && s.isAvailable);
-    if (byName.length === 1) return byName[0];
-    if (byName.length > 1) {
-      const booted2 = byName.find((s) => s.state === "Booted");
-      if (booted2) return booted2;
-      return byName[0];
-    }
-    const fuzzy = all.filter((s) => s.name.includes(identifier) && s.isAvailable);
-    if (fuzzy.length === 1) return fuzzy[0];
-    if (fuzzy.length > 1) return fuzzy.find((s) => s.state === "Booted") || fuzzy[0];
-    throw new Error(`Simulator '${identifier}' not found. Run: xcrun simctl list devices available`);
-  }
-  const booted = all.find((s) => s.state === "Booted");
-  if (booted) return booted;
-  if (all.length === 0) {
-    throw new Error(
-      'No iOS Simulators available. Create one with:\n  xcrun simctl create "iPhone 16 Pro" "com.apple.CoreSimulator.SimDeviceType.iPhone-16-Pro"'
-    );
-  }
-  return all[0];
-}
-async function bootSimulator(udid) {
-  const sims = await listSimulators();
-  const sim = sims.find((s) => s.udid === udid);
-  if (sim?.state === "Booted") return;
-  await simctl("boot", udid);
-  const deadline = Date.now() + 3e4;
-  while (Date.now() < deadline) {
-    const current = await listSimulators();
-    const updated = current.find((s) => s.udid === udid);
-    if (updated?.state === "Booted") return;
-    await new Promise((r2) => setTimeout(r2, 1e3));
-  }
-  throw new Error(`Simulator ${udid} did not boot within 30 seconds`);
-}
-async function shutdownSimulator(udid) {
-  await simctl("shutdown", udid);
-}
-async function installApp(udid, appPath) {
-  await simctl("install", udid, appPath);
-}
-async function uninstallApp(udid, bundleId) {
-  await simctl("uninstall", udid, bundleId);
-}
-async function launchApp(udid, bundleId, env) {
-  const args = ["launch", udid, bundleId];
-  if (env && Object.keys(env).length > 0) {
-    for (const [key, value] of Object.entries(env)) {
-      args.push(`SIMCTL_CHILD_${key}=${value}`);
-    }
-  }
-  await simctl(...args);
+  const dir = path10.dirname(stateFilePath());
+  fs10.mkdirSync(dir, { recursive: true });
+  fs10.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
 }
-async function terminateApp(udid, bundleId) {
+function clearState() {
   try {
-    await simctl("terminate", udid, bundleId);
+    fs10.unlinkSync(stateFilePath());
   } catch {
   }
 }
-async function isAppInstalled(udid, bundleId) {
+async function checkHealth(port = DRIVER_PORT2) {
   try {
-    await simctl("get_app_container", udid, bundleId);
-    return true;
+    const resp = await fetch(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(2e3) });
+    return resp.ok;
   } catch {
     return false;
   }
 }
-async function grantPermission(udid, bundleId, permission) {
-  await simctl("privacy", udid, "grant", permission, bundleId);
-}
-async function revokePermission(udid, bundleId, permission) {
-  await simctl("privacy", udid, "revoke", permission, bundleId);
-}
-async function resetPermissions(udid, bundleId) {
-  await simctl("privacy", udid, "reset", "all", bundleId);
-}
-async function screenshotSimulator(udid, outputPath) {
-  await simctl("io", udid, "screenshot", outputPath);
-}
-async function getAppContainer(udid, bundleId, container = "data") {
-  return simctl("get_app_container", udid, bundleId, container);
-}
-async function openURL(udid, url) {
-  await simctl("openurl", udid, url);
-}
-async function addMedia(udid, ...paths) {
-  await simctl("addmedia", udid, ...paths);
+async function status() {
+  const state = readState();
+  if (!state) return { running: false, state: null, healthy: false };
+  const healthy = await checkHealth(state.port);
+  if (!healthy) {
+    clearState();
+    return { running: false, state, healthy: false };
+  }
+  return { running: true, state, healthy: true };
 }
-async function setStatusBar(udid, overrides) {
-  const args = ["status_bar", udid, "override"];
-  if (overrides.time) args.push("--time", overrides.time);
-  if (overrides.batteryLevel !== void 0) args.push("--batteryLevel", String(overrides.batteryLevel));
-  if (overrides.batteryState) args.push("--batteryState", overrides.batteryState);
-  if (overrides.cellularBars !== void 0) args.push("--cellularBars", String(overrides.cellularBars));
-  if (overrides.wifiBars !== void 0) args.push("--wifiBars", String(overrides.wifiBars));
-  if (overrides.operatorName) args.push("--operatorName", overrides.operatorName);
-  await simctl(...args);
+async function stopDriver() {
+  const state = readState();
+  if (!state) return;
+  try {
+    (0, import_child_process7.execSync)(`adb -s ${state.serial} shell am force-stop io.ulpi.browse.driver.test`, { stdio: "pipe", timeout: 5e3 });
+    (0, import_child_process7.execSync)(`adb -s ${state.serial} shell am force-stop io.ulpi.browse.driver`, { stdio: "pipe", timeout: 5e3 });
+    (0, import_child_process7.execSync)(`adb -s ${state.serial} forward --remove tcp:${state.port}`, { stdio: "pipe", timeout: 5e3 });
+  } catch {
+  }
+  clearState();
 }
-async function clearStatusBar(udid) {
-  await simctl("status_bar", udid, "clear");
+async function stop() {
+  const state = readState();
+  if (!state) return "No Android device/emulator running.";
+  try {
+    (0, import_child_process7.execSync)(`adb -s ${state.serial} shell am force-stop io.ulpi.browse.driver.test`, { stdio: "pipe", timeout: 5e3 });
+    (0, import_child_process7.execSync)(`adb -s ${state.serial} shell am force-stop io.ulpi.browse.driver`, { stdio: "pipe", timeout: 5e3 });
+    (0, import_child_process7.execSync)(`adb -s ${state.serial} forward --remove tcp:${state.port}`, { stdio: "pipe", timeout: 5e3 });
+    if (state.serial.startsWith("emulator-")) {
+      (0, import_child_process7.execSync)(`adb -s ${state.serial} emu kill`, { stdio: "pipe", timeout: 1e4 });
+    }
+  } catch {
+  }
+  clearState();
+  return `Android stopped (${state.device}).`;
 }
-async function checkXcodeTools() {
+async function startAndroid(opts = {}) {
+  const log2 = opts.log || ((msg) => process.stderr.write(`[browse] ${msg}
+`));
+  const port = DRIVER_PORT2;
+  let pendingApkInstall = null;
+  if (opts.app) {
+    const { isAppFilePath: isAppFilePath2 } = await Promise.resolve().then(() => (init_resolve_app(), resolve_app_exports));
+    if (isAppFilePath2(opts.app)) {
+      pendingApkInstall = path10.resolve(opts.app);
+    }
+  }
+  const existing = readState();
+  if (existing) {
+    const healthy = await checkHealth(existing.port);
+    if (healthy) {
+      if (opts.app && existing.app !== opts.app) {
+        log2(`Switching to ${opts.app}...`);
+        await stopDriver();
+      } else {
+        return existing;
+      }
+    }
+    log2("Cleaning up stale driver...");
+    await stopDriver();
+  }
+  log2("Finding Android device...");
+  const { ensureAndroidBridge: ensureAndroidBridge2, createAndroidBridge: createAndroidBridge2, AdbNotFoundError: AdbNotFoundError2, installAdb: installAdb2 } = await Promise.resolve().then(() => (init_bridge(), bridge_exports));
+  let serial;
   try {
-    await execFileAsync("xcrun", ["--version"], { timeout: 5e3 });
+    serial = await ensureAndroidBridge2(opts.device);
+  } catch (err) {
+    if (err instanceof AdbNotFoundError2) {
+      log2("adb not found. Attempting to install...");
+      const installed = await installAdb2(log2);
+      if (!installed) throw err;
+      try {
+        serial = await ensureAndroidBridge2(opts.device);
+      } catch (retryErr) {
+        if (retryErr.message?.includes("No booted Android device")) {
+          const { ensureEmulator: ensureEmulator2 } = await Promise.resolve().then(() => (init_emulator(), emulator_exports));
+          serial = await ensureEmulator2(log2, opts.visible);
+        } else {
+          throw retryErr;
+        }
+      }
+    } else if (err.message?.includes("No booted Android device")) {
+      const { ensureEmulator: ensureEmulator2 } = await Promise.resolve().then(() => (init_emulator(), emulator_exports));
+      serial = await ensureEmulator2(log2, opts.visible);
+    } else {
+      throw err;
+    }
+  }
+  let deviceName = serial;
+  try {
+    deviceName = (0, import_child_process7.execSync)(`adb -s ${serial} shell getprop ro.product.model`, {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim() || serial;
   } catch {
-    throw new Error(
-      "Xcode Command Line Tools not found.\nInstall with: xcode-select --install\nOr install Xcode from the Mac App Store."
-    );
   }
+  const driverApkDir = path10.resolve(__dirname3, "../../../browse-android");
+  const apkPath = path10.join(driverApkDir, "app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk");
+  if (!fs10.existsSync(apkPath) && fs10.existsSync(path10.join(driverApkDir, "gradlew"))) {
+    log2("Building Android driver APK...");
+    try {
+      const { findSdkRoot: findSdkRoot2, ensureJavaHome: ensureJavaHome2 } = await Promise.resolve().then(() => (init_emulator(), emulator_exports));
+      ensureJavaHome2();
+      if (!process.env.ANDROID_HOME) {
+        const sdkRoot = findSdkRoot2();
+        if (sdkRoot) process.env.ANDROID_HOME = sdkRoot;
+      }
+      (0, import_child_process7.execSync)("./gradlew :app:assembleDebug :app:assembleDebugAndroidTest --stacktrace", {
+        cwd: driverApkDir,
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: 3e5
+      });
+      log2("APK built.");
+    } catch (err) {
+      const stdout = err.stdout?.toString() || "";
+      const stderr = err.stderr?.toString() || "";
+      const combined = stdout + "\n" + stderr;
+      const lines = combined.split("\n");
+      const errorLines = lines.filter(
+        (l) => !l.startsWith("	at ") && !l.startsWith("	at ") && (l.includes("error") || l.includes("Error") || l.includes("FAILURE") || l.includes("Could not") || l.includes("wrong") || l.includes("Cannot") || l.includes("SDK") || l.includes("missing"))
+      );
+      log2(`APK build failed:
+${errorLines.slice(0, 10).join("\n") || lines.slice(0, 15).join("\n")}`);
+    }
+  }
+  if (pendingApkInstall) {
+    const { resolveAndroidApp: resolveAndroidApp2 } = await Promise.resolve().then(() => (init_resolve_app(), resolve_app_exports));
+    opts.app = await resolveAndroidApp2(pendingApkInstall, serial, log2);
+  }
+  const targetApp = opts.app || "com.android.settings";
+  log2(`Launching ${targetApp}...`);
   try {
-    await execFileAsync("xcrun", ["simctl", "help"], { timeout: 5e3 });
+    (0, import_child_process7.execSync)(`adb -s ${serial} shell am start -a android.intent.action.MAIN -c android.intent.category.LAUNCHER -p ${targetApp}`, {
+      stdio: "pipe",
+      timeout: 1e4
+    });
   } catch {
-    throw new Error(
-      "simctl not available. Ensure Xcode is installed and selected:\n  sudo xcode-select -s /Applications/Xcode.app"
-    );
+    try {
+      (0, import_child_process7.execSync)(`adb -s ${serial} shell monkey -p ${targetApp} -c android.intent.category.LAUNCHER 1`, {
+        stdio: "pipe",
+        timeout: 1e4
+      });
+    } catch {
+    }
   }
+  await sleep(2e3);
+  log2("Starting driver...");
+  await createAndroidBridge2(serial, targetApp);
+  const state = {
+    platform: "android",
+    device: deviceName,
+    serial,
+    app: targetApp,
+    port,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeState(state);
+  return state;
 }
-var import_child_process6, import_util, execFileAsync;
-var init_controller = __esm({
-  "src/app/ios/controller.ts"() {
+var fs10, path10, import_child_process7, import_url3, __dirname3, DRIVER_PORT2, sleep;
+var init_sim_service = __esm({
+  "src/app/android/sim-service.ts"() {
     "use strict";
-    import_child_process6 = require("child_process");
-    import_util = require("util");
-    execFileAsync = (0, import_util.promisify)(import_child_process6.execFile);
+    fs10 = __toESM(require("fs"), 1);
+    path10 = __toESM(require("path"), 1);
+    import_child_process7 = require("child_process");
+    import_url3 = require("url");
+    __dirname3 = path10.dirname((0, import_url3.fileURLToPath)(__import_meta_url));
+    DRIVER_PORT2 = 7779;
+    sleep = (ms) => new Promise((r2) => setTimeout(r2, ms));
   }
 });
 
@@ -2299,11 +2474,11 @@ function createIOSBridge(udid, bundleId, port = DEFAULT_RUNNER_PORT) {
       const raw = await runnerRequest(port, "/tree");
       return convertTree(raw);
     },
-    async action(path24, actionName) {
-      return runnerRequest(port, "/action", { path: path24, actionName });
+    async action(path25, actionName) {
+      return runnerRequest(port, "/action", { path: path25, actionName });
     },
-    async setValue(path24, value) {
-      return runnerRequest(port, "/set-value", { path: path24, value });
+    async setValue(path25, value) {
+      return runnerRequest(port, "/set-value", { path: path25, value });
     },
     async type(text) {
       return runnerRequest(port, "/type", { text });
@@ -2359,35 +2534,35 @@ function resolveStateDir2() {
   if (localDir) return localDir;
   let dir = process.cwd();
   for (let i = 0; i < 20; i++) {
-    if (fs10.existsSync(path10.join(dir, ".git")) || fs10.existsSync(path10.join(dir, ".claude"))) {
-      const browseDir = path10.join(dir, ".browse");
-      fs10.mkdirSync(browseDir, { recursive: true });
+    if (fs11.existsSync(path11.join(dir, ".git")) || fs11.existsSync(path11.join(dir, ".claude"))) {
+      const browseDir = path11.join(dir, ".browse");
+      fs11.mkdirSync(browseDir, { recursive: true });
       return browseDir;
     }
-    const parent = path10.dirname(dir);
+    const parent = path11.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return "/tmp";
 }
 function stateFilePath2() {
-  return path10.join(resolveStateDir2(), "sim-state.json");
+  return path11.join(resolveStateDir2(), "sim-state.json");
 }
 function readState2() {
   try {
-    return JSON.parse(fs10.readFileSync(stateFilePath2(), "utf-8"));
+    return JSON.parse(fs11.readFileSync(stateFilePath2(), "utf-8"));
   } catch {
     return null;
   }
 }
 function writeState2(state) {
-  const dir = path10.dirname(stateFilePath2());
-  fs10.mkdirSync(dir, { recursive: true });
-  fs10.writeFileSync(stateFilePath2(), JSON.stringify(state, null, 2));
+  const dir = path11.dirname(stateFilePath2());
+  fs11.mkdirSync(dir, { recursive: true });
+  fs11.writeFileSync(stateFilePath2(), JSON.stringify(state, null, 2));
 }
 function clearState2() {
   try {
-    fs10.unlinkSync(stateFilePath2());
+    fs11.unlinkSync(stateFilePath2());
   } catch {
   }
 }
@@ -2401,11 +2576,11 @@ async function checkHealth2(port = DEFAULT_PORT) {
 }
 async function configureTarget(port, bundleId, udid) {
   if (bundleId !== "io.ulpi.browse-ios-runner") {
-    const { execSync: execSync7 } = await import("child_process");
+    const { execSync: execSync8 } = await import("child_process");
     const deviceId = udid || readState2()?.udid;
     if (deviceId) {
       try {
-        execSync7(`xcrun simctl launch ${deviceId} ${bundleId}`, { stdio: "pipe", timeout: 3e4 });
+        execSync8(`xcrun simctl launch ${deviceId} ${bundleId}`, { stdio: "pipe", timeout: 3e4 });
       } catch {
       }
     }
@@ -2424,7 +2599,7 @@ async function status2() {
   return { running: true, state, healthy: true };
 }
 async function killStaleRunners(port, statePid) {
-  const { execSync: execSync7 } = await import("child_process");
+  const { execSync: execSync8 } = await import("child_process");
   if (statePid) {
     try {
       process.kill(statePid, "SIGKILL");
@@ -2432,11 +2607,11 @@ async function killStaleRunners(port, statePid) {
     }
   }
   try {
-    execSync7('pkill -9 -f "xcodebuild.*BrowseRunnerApp"', { stdio: "pipe", timeout: 5e3 });
+    execSync8('pkill -9 -f "xcodebuild.*BrowseRunnerApp"', { stdio: "pipe", timeout: 5e3 });
   } catch {
   }
   try {
-    const lsof = execSync7(`lsof -ti :${port}`, { stdio: "pipe", timeout: 5e3 }).toString().trim();
+    const lsof = execSync8(`lsof -ti :${port}`, { stdio: "pipe", timeout: 5e3 }).toString().trim();
     for (const pid of lsof.split("\n").filter(Boolean)) {
       try {
         process.kill(parseInt(pid, 10), "SIGKILL");
@@ -2448,7 +2623,7 @@ async function killStaleRunners(port, statePid) {
   for (let i = 0; i < 5; i++) {
     await sleep2(1e3);
     try {
-      execSync7(`lsof -ti :${port}`, { stdio: "pipe", timeout: 2e3 });
+      execSync8(`lsof -ti :${port}`, { stdio: "pipe", timeout: 2e3 });
     } catch {
       break;
     }
@@ -2465,6 +2640,14 @@ async function startIOS(opts = {}) {
   const log2 = opts.log || ((msg) => process.stderr.write(`[browse] ${msg}
 `));
   const port = parseInt(process.env.BROWSE_RUNNER_PORT || "", 10) || DEFAULT_PORT;
+  if (opts.app) {
+    const { isAppFilePath: isAppFilePath2, resolveIOSApp: resolveIOSApp2 } = await Promise.resolve().then(() => (init_resolve_app(), resolve_app_exports));
+    if (isAppFilePath2(opts.app)) {
+      const sim2 = await resolveSimulator(opts.device);
+      if (sim2.state !== "Booted") await bootSimulator(sim2.udid);
+      opts.app = await resolveIOSApp2(opts.app, sim2.udid, log2);
+    }
+  }
   const existing = readState2();
   if (existing) {
     const healthy = await checkHealth2(existing.port);
@@ -2505,23 +2688,23 @@ async function startIOS(opts = {}) {
     }
   }
   const runnerCandidates = [
-    path10.resolve(__dirname_svc, "../../../browse-ios-runner"),
-    path10.resolve(__dirname_svc, "../../browse-ios-runner"),
-    path10.resolve(__dirname_svc, "../bin/browse-ios-runner")
+    path11.resolve(__dirname_svc, "../../../browse-ios-runner"),
+    path11.resolve(__dirname_svc, "../../browse-ios-runner"),
+    path11.resolve(__dirname_svc, "../bin/browse-ios-runner")
   ];
-  const runnerDir = runnerCandidates.find((d) => fs10.existsSync(path10.join(d, "project.yml"))) || runnerCandidates[0];
-  const { execSync: execSync7 } = await import("child_process");
-  if (!fs10.existsSync(path10.join(runnerDir, "BrowseRunner.xcodeproj", "project.pbxproj"))) {
+  const runnerDir = runnerCandidates.find((d) => fs11.existsSync(path11.join(d, "project.yml"))) || runnerCandidates[0];
+  const { execSync: execSync8 } = await import("child_process");
+  if (!fs11.existsSync(path11.join(runnerDir, "BrowseRunner.xcodeproj", "project.pbxproj"))) {
     log2("Generating Xcode project...");
-    execSync7("xcodegen generate --spec project.yml", { cwd: runnerDir, stdio: "pipe" });
+    execSync8("xcodegen generate --spec project.yml", { cwd: runnerDir, stdio: "pipe" });
   }
   log2("Building iOS runner...");
-  execSync7(
+  execSync8(
     `xcodebuild build-for-testing -project BrowseRunner.xcodeproj -scheme BrowseRunnerApp -sdk iphonesimulator -destination "id=${sim.udid}" -derivedDataPath .build CODE_SIGN_IDENTITY="" CODE_SIGNING_ALLOWED=NO -quiet`,
     { cwd: runnerDir, stdio: "pipe", timeout: 12e4 }
   );
   log2("Starting runner...");
-  const proc = (0, import_child_process7.spawn)("xcodebuild", [
+  const proc = (0, import_child_process8.spawn)("xcodebuild", [
     "test",
     "-project",
     "BrowseRunner.xcodeproj",
@@ -2568,17 +2751,17 @@ async function startIOS(opts = {}) {
   writeState2(state);
   return state;
 }
-var fs10, path10, import_child_process7, import_url4, __filename_svc, __dirname_svc, DEFAULT_PORT, sleep2;
+var fs11, path11, import_child_process8, import_url4, __filename_svc, __dirname_svc, DEFAULT_PORT, sleep2;
 var init_sim_service2 = __esm({
   "src/app/ios/sim-service.ts"() {
     "use strict";
-    fs10 = __toESM(require("fs"), 1);
-    path10 = __toESM(require("path"), 1);
-    import_child_process7 = require("child_process");
+    fs11 = __toESM(require("fs"), 1);
+    path11 = __toESM(require("path"), 1);
+    import_child_process8 = require("child_process");
     import_url4 = require("url");
     init_controller();
     __filename_svc = (0, import_url4.fileURLToPath)(__import_meta_url);
-    __dirname_svc = path10.dirname(__filename_svc);
+    __dirname_svc = path11.dirname(__filename_svc);
     DEFAULT_PORT = 9820;
     sleep2 = (ms) => new Promise((r2) => setTimeout(r2, ms));
   }
@@ -2592,11 +2775,12 @@ __export(sim_cli_exports, {
 async function handleSimCLI(args) {
   const sub = args[0];
   if (!sub || sub === "--help") {
-    console.log("Usage: browse sim start --platform ios|android [--device <name>] [--app <id>] [--visible]");
+    console.log("Usage: browse sim start --platform ios|android [--device <name>] [--app <id-or-path>] [--visible]");
     console.log("       browse sim stop [--platform ios|android]");
     console.log("       browse sim status [--platform ios|android]");
     console.log("");
     console.log("Flags:");
+    console.log("  --app        Bundle ID, package name, or path to .app/.ipa/.apk");
     console.log("  --visible    Open the Simulator window (default: headless/background)");
     return;
   }
@@ -2673,14 +2857,118 @@ async function handleSimCLI(args) {
       console.error(`Unknown platform: '${platform}'. Use ios or android.`);
       process.exit(1);
     }
-    return;
-  }
-  console.error(`Unknown sim subcommand: ${sub}`);
-  process.exit(1);
+    return;
+  }
+  console.error(`Unknown sim subcommand: ${sub}`);
+  process.exit(1);
+}
+var init_sim_cli = __esm({
+  "src/sim-cli.ts"() {
+    "use strict";
+  }
+});
+
+// src/app/macos/bridge.ts
+var bridge_exports3 = {};
+__export(bridge_exports3, {
+  createMacOSBridge: () => createMacOSBridge,
+  ensureMacOSBridge: () => ensureMacOSBridge,
+  resolveBridgePath: () => resolveBridgePath
+});
+function resolveBridgePath() {
+  const candidates = [
+    // 1. Local dev build
+    path12.resolve(__dirname_bridge, "../../../browse-ax/.build/release/browse-ax"),
+    path12.resolve(__dirname_bridge, "../../../browse-ax/.build/debug/browse-ax"),
+    // 2. Installed alongside source (bin/ at project root)
+    path12.resolve(__dirname_bridge, "../../bin/browse-ax"),
+    // 3. Bundled build (dist/browse.cjs → ../bin/)
+    path12.resolve(__dirname_bridge, "../bin/browse-ax")
+  ];
+  for (const p of candidates) {
+    if (fs12.existsSync(p)) return p;
+  }
+  const lazyPath = path12.join(
+    process.env.BROWSE_LOCAL_DIR || path12.join(process.cwd(), ".browse"),
+    "bin",
+    "browse-ax"
+  );
+  if (fs12.existsSync(lazyPath)) return lazyPath;
+  throw new Error(
+    "browse-ax binary not found. Run: browse enable macos\nOr build manually: cd browse-ax && swift build -c release"
+  );
+}
+async function ensureMacOSBridge() {
+  if (process.platform !== "darwin") {
+    throw new Error("App automation requires macOS (uses Accessibility API)");
+  }
+  return resolveBridgePath();
+}
+async function execBridge(bridgePath, args) {
+  return new Promise((resolve10, reject) => {
+    const proc = (0, import_child_process9.spawn)(bridgePath, args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const chunks = [];
+    const errChunks = [];
+    proc.stdout.on("data", (c) => chunks.push(c));
+    proc.stderr.on("data", (c) => errChunks.push(c));
+    proc.on("close", (code) => {
+      const stdout = Buffer.concat(chunks).toString("utf-8").trim();
+      const stderr = Buffer.concat(errChunks).toString("utf-8").trim();
+      if (code !== 0) {
+        try {
+          const err = JSON.parse(stderr || stdout);
+          reject(new Error(err.error || `Bridge exited with code ${code}`));
+        } catch {
+          reject(new Error(stderr || `Bridge exited with code ${code}`));
+        }
+        return;
+      }
+      try {
+        resolve10(JSON.parse(stdout));
+      } catch {
+        reject(new Error(`Invalid bridge output: ${stdout.slice(0, 200)}`));
+      }
+    });
+  });
+}
+function createMacOSBridge(bridgePath, pid) {
+  const base = ["--pid", String(pid)];
+  return {
+    async tree() {
+      return execBridge(bridgePath, [...base, "tree"]);
+    },
+    async action(nodePath, actionName) {
+      return execBridge(bridgePath, [...base, "action", JSON.stringify(nodePath), actionName]);
+    },
+    async setValue(nodePath, value) {
+      return execBridge(bridgePath, [...base, "set-value", JSON.stringify(nodePath), value]);
+    },
+    async type(text) {
+      return execBridge(bridgePath, [...base, "type", text]);
+    },
+    async press(key) {
+      return execBridge(bridgePath, [...base, "press", key]);
+    },
+    async screenshot(outputPath) {
+      return execBridge(bridgePath, [...base, "screenshot", outputPath]);
+    },
+    async state() {
+      return execBridge(bridgePath, [...base, "state"]);
+    }
+  };
 }
-var init_sim_cli = __esm({
-  "src/sim-cli.ts"() {
+var import_child_process9, path12, fs12, import_url5, __filename_bridge2, __dirname_bridge;
+var init_bridge3 = __esm({
+  "src/app/macos/bridge.ts"() {
     "use strict";
+    import_child_process9 = require("child_process");
+    path12 = __toESM(require("path"), 1);
+    fs12 = __toESM(require("fs"), 1);
+    import_url5 = require("url");
+    __filename_bridge2 = (0, import_url5.fileURLToPath)(__import_meta_url);
+    __dirname_bridge = path12.dirname(__filename_bridge2);
   }
 });
 
@@ -2689,153 +2977,173 @@ var enable_exports = {};
 __export(enable_exports, {
   handleEnable: () => handleEnable
 });
+function findPath(candidates) {
+  return candidates.find((p) => fs13.existsSync(p)) || null;
+}
 async function enableAndroid() {
   log("Enabling Android...");
-  const { ensureAndroidBridge: ensureAndroidBridge2, AdbNotFoundError: AdbNotFoundError2, installAdb: installAdb2 } = await Promise.resolve().then(() => (init_bridge(), bridge_exports));
-  try {
-    await ensureAndroidBridge2();
-    log("adb: already available");
-  } catch (err) {
-    if (err instanceof AdbNotFoundError2) {
-      const ok = await installAdb2(log);
-      if (!ok) throw new Error("Failed to install adb");
-    }
+  const prebuiltApk = findPath([
+    path13.resolve(__dirname_enable, "../bin/browse-android.apk"),
+    path13.resolve(__dirname_enable, "../../bin/browse-android.apk"),
+    path13.resolve(__dirname_enable, "browse-android.apk")
+  ]);
+  if (prebuiltApk) {
+    log(`Driver APK: ${prebuiltApk}`);
+    log("Android ready (pre-built).");
+    return;
   }
-  const { ensureJavaHome: ensureJavaHome2, findSdkRoot: findSdkRoot2, installSdk: installSdk2, installSystemImage: installSystemImage2, createAvd: createAvd2 } = await Promise.resolve().then(() => (init_emulator(), emulator_exports));
-  ensureJavaHome2();
+  log("Pre-built APK not found, building from source...");
+  const { ensureJavaHome: ensureJavaHome2, findSdkRoot: findSdkRoot2, installSdk: installSdk2, createAvd: createAvd2 } = await Promise.resolve().then(() => (init_emulator(), emulator_exports));
+  const { installAdb: installAdb2 } = await Promise.resolve().then(() => (init_bridge(), bridge_exports));
   try {
-    (0, import_child_process8.execSync)("java -version", { stdio: "ignore", timeout: 5e3 });
-    log("Java: available");
+    (0, import_child_process10.execSync)("adb version", { stdio: "ignore", timeout: 5e3 });
+    log("adb: available");
   } catch {
-    log("Java not found. Run: brew install openjdk@21");
+    log("Installing adb...");
+    await installAdb2(log);
+  }
+  ensureJavaHome2();
+  const hasJava = () => {
+    try {
+      (0, import_child_process10.execSync)("java -version", { stdio: "ignore", timeout: 5e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (!hasJava() && process.platform === "darwin") {
+    log("Installing Java (JDK 21)...");
+    try {
+      (0, import_child_process10.execSync)("brew install openjdk@21", { stdio: ["ignore", "pipe", "pipe"], timeout: 3e5 });
+    } catch {
+    }
+    ensureJavaHome2();
   }
+  if (!hasJava()) throw new Error("Java not found. Install: brew install openjdk@21");
+  log("Java: available");
   let sdkRoot = findSdkRoot2();
-  if (!sdkRoot) {
-    sdkRoot = await installSdk2(log);
-  }
-  if (sdkRoot) {
-    log(`SDK: ${sdkRoot}`);
-    const sdkMgr = [
-      path11.join(sdkRoot, "cmdline-tools/latest/bin/sdkmanager"),
-      path11.join(sdkRoot, "bin/sdkmanager")
-    ].find((p) => fs11.existsSync(p));
-    if (sdkMgr) {
+  if (!sdkRoot) sdkRoot = await installSdk2(log);
+  if (!sdkRoot) throw new Error("Android SDK not found.");
+  log(`SDK: ${sdkRoot}`);
+  const sdkMgr = findPath([
+    path13.join(sdkRoot, "cmdline-tools/latest/bin/sdkmanager"),
+    path13.join(sdkRoot, "bin/sdkmanager")
+  ]);
+  if (sdkMgr) {
+    try {
+      (0, import_child_process10.execSync)(`yes | "${sdkMgr}" --licenses`, { stdio: "ignore", timeout: 6e4, shell: "/bin/bash" });
+    } catch {
+    }
+    for (const comp of ["emulator", "platform-tools", "platforms;android-35", "build-tools;35.0.0", "system-images;android-35;google_apis;arm64-v8a"]) {
       try {
-        (0, import_child_process8.execSync)(`yes | "${sdkMgr}" --licenses`, { stdio: "ignore", timeout: 6e4, shell: "/bin/bash" });
+        (0, import_child_process10.execSync)(`"${sdkMgr}" --install "${comp}"`, { stdio: "ignore", timeout: 3e5 });
       } catch {
       }
-      const components = ["emulator", "platform-tools", "platforms;android-35", "build-tools;35.0.0", "system-images;android-35;google_apis;arm64-v8a"];
-      for (const comp of components) {
-        try {
-          (0, import_child_process8.execSync)(`"${sdkMgr}" --install "${comp}"`, { stdio: "ignore", timeout: 3e5 });
-        } catch {
-        }
-      }
-      log("SDK components: installed");
-      const avdMgr = [
-        path11.join(sdkRoot, "cmdline-tools/latest/bin/avdmanager"),
-        path11.join(sdkRoot, "bin/avdmanager")
-      ].find((p) => fs11.existsSync(p));
-      if (avdMgr) {
-        try {
-          const avds = (0, import_child_process8.execSync)(`"${avdMgr}" list avd -c`, { encoding: "utf-8", timeout: 1e4, stdio: ["ignore", "pipe", "pipe"] }).trim();
-          if (!avds.includes("browse_default")) {
-            createAvd2(sdkRoot, avdMgr, log);
-          } else {
-            log("AVD browse_default: exists");
-          }
-        } catch {
-        }
+    }
+    log("SDK components: installed");
+  }
+  const avdMgr = findPath([
+    path13.join(sdkRoot, "cmdline-tools/latest/bin/avdmanager"),
+    path13.join(sdkRoot, "bin/avdmanager")
+  ]);
+  if (avdMgr) {
+    try {
+      const avds = (0, import_child_process10.execSync)(`"${avdMgr}" list avd -c`, { encoding: "utf-8", timeout: 1e4, stdio: ["ignore", "pipe", "pipe"] }).trim();
+      if (!avds.includes("browse_default")) {
+        createAvd2(sdkRoot, avdMgr, log);
+      } else {
+        log("AVD: browse_default exists");
       }
+    } catch {
     }
   }
-  const driverDir = path11.resolve(__dirname_enable, "../browse-android");
-  const apkPath = path11.join(driverDir, "app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk");
-  if (!fs11.existsSync(apkPath) && fs11.existsSync(path11.join(driverDir, "gradlew"))) {
-    const { findSdkRoot: findSdkRoot3, ensureJavaHome: ensureJavaHome3 } = await Promise.resolve().then(() => (init_emulator(), emulator_exports));
-    ensureJavaHome3();
-    const sdkRoot2 = findSdkRoot3();
-    if (sdkRoot2) process.env.ANDROID_HOME = sdkRoot2;
+  const driverDir = findPath([
+    path13.resolve(__dirname_enable, "../browse-android"),
+    path13.resolve(__dirname_enable, "../../browse-android")
+  ].filter((d) => fs13.existsSync(path13.join(d, "gradlew"))));
+  if (driverDir) {
+    if (!process.env.ANDROID_HOME) process.env.ANDROID_HOME = sdkRoot;
     log("Building Android driver APK...");
     try {
-      (0, import_child_process8.execSync)("./gradlew :app:assembleDebug :app:assembleDebugAndroidTest --no-daemon", {
+      (0, import_child_process10.execSync)("./gradlew :app:assembleDebug :app:assembleDebugAndroidTest --no-daemon", {
         cwd: driverDir,
         stdio: ["ignore", "pipe", "pipe"],
         timeout: 3e5
       });
-      log("Android driver APK built.");
+      log("APK built.");
     } catch (err) {
       log(`APK build failed: ${err.message?.split("\n")[0]}`);
     }
-  } else if (fs11.existsSync(apkPath)) {
-    log("Android driver APK: already built");
   }
   log("Android enabled.");
 }
 async function enableIOS() {
   log("Enabling iOS...");
-  if (process.platform !== "darwin") {
-    throw new Error("iOS requires macOS with Xcode installed.");
-  }
+  if (process.platform !== "darwin") throw new Error("iOS requires macOS with Xcode.");
   try {
-    (0, import_child_process8.execSync)("xcodebuild -version", { stdio: "pipe", timeout: 1e4 });
+    (0, import_child_process10.execSync)("xcodebuild -version", { stdio: "pipe", timeout: 1e4 });
     log("Xcode: available");
   } catch {
-    throw new Error("Xcode not found. Install from the App Store or: xcode-select --install");
+    throw new Error("Xcode not found. Install from the App Store.");
   }
   try {
-    (0, import_child_process8.execSync)("which xcodegen", { stdio: "pipe", timeout: 5e3 });
-    log("xcodegen: available");
+    (0, import_child_process10.execSync)("which xcodegen", { stdio: "pipe", timeout: 5e3 });
   } catch {
     log("Installing xcodegen...");
     try {
-      (0, import_child_process8.execSync)("brew install xcodegen", { stdio: ["ignore", "pipe", "pipe"], timeout: 12e4 });
+      (0, import_child_process10.execSync)("brew install xcodegen", { stdio: ["ignore", "pipe", "pipe"], timeout: 12e4 });
     } catch {
       throw new Error("xcodegen not found. Install: brew install xcodegen");
     }
   }
-  const runnerDir = path11.resolve(__dirname_enable, "../browse-ios-runner");
-  if (fs11.existsSync(path11.join(runnerDir, "project.yml"))) {
-    if (!fs11.existsSync(path11.join(runnerDir, "BrowseRunner.xcodeproj", "project.pbxproj"))) {
-      log("Generating Xcode project...");
-      (0, import_child_process8.execSync)("xcodegen generate --spec project.yml", { cwd: runnerDir, stdio: "pipe" });
-    }
-    const { resolveSimulator: resolveSimulator2 } = await Promise.resolve().then(() => (init_controller(), controller_exports));
-    let udid;
-    try {
-      const sim = await resolveSimulator2();
-      udid = sim.udid;
-    } catch {
-      log("No iOS Simulator found. Skipping pre-build (will build on first sim start).");
-      log("iOS enabled (source ready).");
-      return;
-    }
+  log("xcodegen: available");
+  const runnerDir = findPath([
+    path13.resolve(__dirname_enable, "../browse-ios-runner"),
+    path13.resolve(__dirname_enable, "../../browse-ios-runner"),
+    path13.resolve(__dirname_enable, "../bin/browse-ios-runner")
+  ].filter((d) => fs13.existsSync(path13.join(d, "project.yml"))));
+  if (!runnerDir) {
+    throw new Error("iOS runner source not found. Reinstall: npm install -g @ulpi/browse");
+  }
+  if (!fs13.existsSync(path13.join(runnerDir, "BrowseRunner.xcodeproj", "project.pbxproj"))) {
+    log("Generating Xcode project...");
+    (0, import_child_process10.execSync)("xcodegen generate --spec project.yml", { cwd: runnerDir, stdio: "pipe" });
+  }
+  const { resolveSimulator: resolveSimulator2 } = await Promise.resolve().then(() => (init_controller(), controller_exports));
+  try {
+    const sim = await resolveSimulator2();
     log("Building iOS runner...");
-    (0, import_child_process8.execSync)(
-      `xcodebuild build-for-testing -project BrowseRunner.xcodeproj -scheme BrowseRunnerApp -sdk iphonesimulator -destination "id=${udid}" -derivedDataPath .build CODE_SIGN_IDENTITY="" CODE_SIGNING_ALLOWED=NO -quiet`,
+    (0, import_child_process10.execSync)(
+      `xcodebuild build-for-testing -project BrowseRunner.xcodeproj -scheme BrowseRunnerApp -sdk iphonesimulator -destination "id=${sim.udid}" -derivedDataPath .build CODE_SIGN_IDENTITY="" CODE_SIGNING_ALLOWED=NO -quiet`,
       { cwd: runnerDir, stdio: "pipe", timeout: 12e4 }
     );
     log("iOS runner built.");
+  } catch {
+    log("No simulator found. Runner will build on first sim start.");
   }
   log("iOS enabled.");
 }
 async function enableMacOS() {
   log("Enabling macOS...");
-  if (process.platform !== "darwin") {
-    throw new Error("macOS app automation requires macOS.");
+  if (process.platform !== "darwin") throw new Error("macOS app automation requires macOS.");
+  const { resolveBridgePath: resolveBridgePath2 } = await Promise.resolve().then(() => (init_bridge3(), bridge_exports3));
+  try {
+    const existing = resolveBridgePath2();
+    log(`browse-ax: ${existing}`);
+    log("macOS enabled.");
+    return;
+  } catch {
   }
-  const axDir = path11.resolve(__dirname_enable, "../browse-ax");
-  const axBin = path11.join(axDir, ".build/release/browse-ax");
-  if (fs11.existsSync(path11.join(axDir, "Package.swift"))) {
-    if (fs11.existsSync(axBin)) {
-      log("browse-ax: already built");
-    } else {
-      log("Building browse-ax...");
-      (0, import_child_process8.execSync)("swift build -c release", { cwd: axDir, stdio: ["ignore", "pipe", "pipe"], timeout: 12e4 });
-      log("browse-ax built.");
-    }
+  const axDir = findPath([
+    path13.resolve(__dirname_enable, "../browse-ax"),
+    path13.resolve(__dirname_enable, "../../browse-ax")
+  ].filter((d) => fs13.existsSync(path13.join(d, "Package.swift"))));
+  if (axDir) {
+    log("Building browse-ax...");
+    (0, import_child_process10.execSync)("swift build -c release", { cwd: axDir, stdio: ["ignore", "pipe", "pipe"], timeout: 12e4 });
+    log("browse-ax built.");
   } else {
-    throw new Error("browse-ax source not found.");
+    throw new Error("browse-ax not found. Reinstall: npm install -g @ulpi/browse");
   }
   log("macOS enabled.");
 }
@@ -2844,8 +3152,8 @@ async function handleEnable(args) {
   if (!platform || platform === "--help") {
     console.log("Usage: browse enable android|ios|macos|all");
     console.log("");
-    console.log("Downloads dependencies and builds native drivers for each platform.");
-    console.log("Run once \u2014 everything is cached for future use.");
+    console.log("Verifies native drivers are ready. Pre-built binaries ship with npm install.");
+    console.log("If missing (building from source), installs dependencies and builds them.");
     return;
   }
   const platforms = platform === "all" ? ["android", "ios", "macos"] : [platform];
@@ -2872,15 +3180,15 @@ async function handleEnable(args) {
     console.log("");
   }
 }
-var import_child_process8, fs11, path11, import_url5, __dirname_enable, log;
+var import_child_process10, fs13, path13, import_url6, __dirname_enable, log;
 var init_enable = __esm({
   "src/enable.ts"() {
     "use strict";
-    import_child_process8 = require("child_process");
-    fs11 = __toESM(require("fs"), 1);
-    path11 = __toESM(require("path"), 1);
-    import_url5 = require("url");
-    __dirname_enable = path11.dirname((0, import_url5.fileURLToPath)(__import_meta_url));
+    import_child_process10 = require("child_process");
+    fs13 = __toESM(require("fs"), 1);
+    path13 = __toESM(require("path"), 1);
+    import_url6 = require("url");
+    __dirname_enable = path13.dirname((0, import_url6.fileURLToPath)(__import_meta_url));
     log = (msg) => process.stderr.write(`[browse] ${msg}
 `);
   }
@@ -3174,8 +3482,8 @@ async function handleReadCommand(command, args, bm, buffers) {
     case "eval": {
       const filePath = args[0];
       if (!filePath) throw new Error("Usage: browse eval <js-file>");
-      if (!fs12.existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
-      const code = fs12.readFileSync(filePath, "utf-8");
+      if (!fs14.existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
+      const code = fs14.readFileSync(filePath, "utf-8");
       const result = await evalCtx.evaluate(code);
       return typeof result === "object" ? JSON.stringify(result, null, 2) : String(result ?? "");
     }
@@ -3515,13 +3823,13 @@ function registerReadDefinitions(registry4) {
     });
   }
 }
-var fs12;
+var fs14;
 var init_read = __esm({
   "src/commands/read.ts"() {
     "use strict";
     init_emulation();
     init_constants();
-    fs12 = __toESM(require("fs"), 1);
+    fs14 = __toESM(require("fs"), 1);
   }
 });
 
@@ -4168,7 +4476,7 @@ async function handleWriteCommand(command, args, bm, domainFilter) {
             const elapsed = Date.now() - start2;
             return `Request matched: ${match.description} (${elapsed}ms)`;
           }
-          await new Promise((resolve9) => setTimeout(resolve9, 100));
+          await new Promise((resolve10) => setTimeout(resolve10, 100));
         }
         const finalMatch = matchNetworkRequest2(cond, buffers);
         const { method, pattern } = parseRequestValue2(requestPattern);
@@ -4213,14 +4521,14 @@ async function handleWriteCommand(command, args, bm, domainFilter) {
         const file = args[1];
         if (!file) throw new Error("Usage: browse cookie export <file>");
         const cookies = await page.context().cookies();
-        fs13.writeFileSync(file, JSON.stringify(cookies, null, 2));
+        fs15.writeFileSync(file, JSON.stringify(cookies, null, 2));
         return `Exported ${cookies.length} cookie(s) to ${file}`;
       }
       if (cookieStr === "import") {
         const file = args[1];
         if (!file) throw new Error("Usage: browse cookie import <file>");
-        if (!fs13.existsSync(file)) throw new Error(`File not found: ${file}`);
-        const cookies = JSON.parse(fs13.readFileSync(file, "utf-8"));
+        if (!fs15.existsSync(file)) throw new Error(`File not found: ${file}`);
+        const cookies = JSON.parse(fs15.readFileSync(file, "utf-8"));
         if (!Array.isArray(cookies)) throw new Error("Cookie file must contain a JSON array of cookie objects");
         await page.context().addCookies(cookies);
         return `Imported ${cookies.length} cookie(s) from ${file}`;
@@ -4287,7 +4595,7 @@ Note: Cookies and tab URLs preserved. localStorage/sessionStorage were reset (Pl
       const [selector, ...filePaths] = args;
       if (!selector || filePaths.length === 0) throw new Error("Usage: browse upload <selector> <file1> [file2] ...");
       for (const fp of filePaths) {
-        if (!fs13.existsSync(fp)) throw new Error(`File not found: ${fp}`);
+        if (!fs15.existsSync(fp)) throw new Error(`File not found: ${fp}`);
       }
       const resolved = bm.resolveRef(selector);
       if ("locator" in resolved) {
@@ -4747,13 +5055,13 @@ function registerWriteDefinitions(registry4) {
     });
   }
 }
-var fs13;
+var fs15;
 var init_write = __esm({
   "src/commands/write.ts"() {
     "use strict";
     init_emulation();
     init_constants();
-    fs13 = __toESM(require("fs"), 1);
+    fs15 = __toESM(require("fs"), 1);
   }
 });
 
@@ -5110,9 +5418,9 @@ ${legend.join("\n")}`;
       try {
         for (const vp of viewports) {
           await page.setViewportSize({ width: vp.width, height: vp.height });
-          const path24 = `${prefix}-${vp.name}.png`;
-          await page.screenshot({ path: path24, fullPage: true });
-          results.push(`${vp.name} (${vp.width}x${vp.height}): ${path24}`);
+          const path25 = `${prefix}-${vp.name}.png`;
+          await page.screenshot({ path: path25, fullPage: true });
+          results.push(`${vp.name} (${vp.width}x${vp.height}): ${path25}`);
         }
       } finally {
         if (originalViewport) {
@@ -5127,13 +5435,13 @@ ${legend.join("\n")}`;
       const diffArgs = args.filter((a) => a !== "--full");
       const baseline = diffArgs[0];
       if (!baseline) throw new Error("Usage: browse screenshot-diff <baseline> [current] [--threshold 0.1] [--full]");
-      if (!fs14.existsSync(baseline)) throw new Error(`Baseline file not found: ${baseline}`);
+      if (!fs16.existsSync(baseline)) throw new Error(`Baseline file not found: ${baseline}`);
       let thresholdPct = 0.1;
       const threshIdx = diffArgs.indexOf("--threshold");
       if (threshIdx !== -1 && diffArgs[threshIdx + 1]) {
         thresholdPct = parseFloat(diffArgs[threshIdx + 1]);
       }
-      const baselineBuffer = fs14.readFileSync(baseline);
+      const baselineBuffer = fs16.readFileSync(baseline);
       let currentBuffer;
       let currentPath;
       for (let i = 1; i < diffArgs.length; i++) {
@@ -5147,8 +5455,8 @@ ${legend.join("\n")}`;
         }
       }
       if (currentPath) {
-        if (!fs14.existsSync(currentPath)) throw new Error(`Current screenshot not found: ${currentPath}`);
-        currentBuffer = fs14.readFileSync(currentPath);
+        if (!fs16.existsSync(currentPath)) throw new Error(`Current screenshot not found: ${currentPath}`);
+        currentBuffer = fs16.readFileSync(currentPath);
       } else {
         const page = bm.getPage();
         currentBuffer = await page.screenshot({ fullPage: isFullPageDiff });
@@ -5158,7 +5466,7 @@ ${legend.join("\n")}`;
       const extIdx = baseline.lastIndexOf(".");
       const diffPath = extIdx > 0 ? baseline.slice(0, extIdx) + "-diff" + baseline.slice(extIdx) : baseline + "-diff.png";
       if (!result.passed && result.diffImage) {
-        fs14.writeFileSync(diffPath, result.diffImage);
+        fs16.writeFileSync(diffPath, result.diffImage);
       }
       return [
         `Pixels: ${result.totalPixels}`,
@@ -5173,11 +5481,11 @@ ${legend.join("\n")}`;
       throw new Error(`Unknown screenshots command: ${command}`);
   }
 }
-var fs14, LOCAL_DIR;
+var fs16, LOCAL_DIR;
 var init_screenshots = __esm({
   "src/commands/meta/screenshots.ts"() {
     "use strict";
-    fs14 = __toESM(require("fs"), 1);
+    fs16 = __toESM(require("fs"), 1);
     LOCAL_DIR = process.env.BROWSE_LOCAL_DIR || "/tmp";
   }
 });
@@ -5259,17 +5567,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path24) {
-      const ctrl = callVisitor(key, node, visitor, path24);
+    function visit_(key, node, visitor, path25) {
+      const ctrl = callVisitor(key, node, visitor, path25);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path24, ctrl);
-        return visit_(key, ctrl, visitor, path24);
+        replaceNode(key, path25, ctrl);
+        return visit_(key, ctrl, visitor, path25);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path24 = Object.freeze(path24.concat(node));
+          path25 = Object.freeze(path25.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path24);
+            const ci = visit_(i, node.items[i], visitor, path25);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5280,13 +5588,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path24 = Object.freeze(path24.concat(node));
-          const ck = visit_("key", node.key, visitor, path24);
+          path25 = Object.freeze(path25.concat(node));
+          const ck = visit_("key", node.key, visitor, path25);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path24);
+          const cv = visit_("value", node.value, visitor, path25);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -5307,17 +5615,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path24) {
-      const ctrl = await callVisitor(key, node, visitor, path24);
+    async function visitAsync_(key, node, visitor, path25) {
+      const ctrl = await callVisitor(key, node, visitor, path25);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path24, ctrl);
-        return visitAsync_(key, ctrl, visitor, path24);
+        replaceNode(key, path25, ctrl);
+        return visitAsync_(key, ctrl, visitor, path25);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path24 = Object.freeze(path24.concat(node));
+          path25 = Object.freeze(path25.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path24);
+            const ci = await visitAsync_(i, node.items[i], visitor, path25);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5328,13 +5636,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path24 = Object.freeze(path24.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path24);
+          path25 = Object.freeze(path25.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path25);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path24);
+          const cv = await visitAsync_("value", node.value, visitor, path25);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -5361,23 +5669,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path24) {
+    function callVisitor(key, node, visitor, path25) {
       if (typeof visitor === "function")
-        return visitor(key, node, path24);
+        return visitor(key, node, path25);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path24);
+        return visitor.Map?.(key, node, path25);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path24);
+        return visitor.Seq?.(key, node, path25);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path24);
+        return visitor.Pair?.(key, node, path25);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path24);
+        return visitor.Scalar?.(key, node, path25);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path24);
+        return visitor.Alias?.(key, node, path25);
       return void 0;
     }
-    function replaceNode(key, path24, node) {
-      const parent = path24[path24.length - 1];
+    function replaceNode(key, path25, node) {
+      const parent = path25[path25.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -5985,10 +6293,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path24, value) {
+    function collectionFromPath(schema, path25, value) {
       let v = value;
-      for (let i = path24.length - 1; i >= 0; --i) {
-        const k = path24[i];
+      for (let i = path25.length - 1; i >= 0; --i) {
+        const k = path25[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -6007,7 +6315,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path24) => path24 == null || typeof path24 === "object" && !!path24[Symbol.iterator]().next().done;
+    var isEmptyPath = (path25) => path25 == null || typeof path25 === "object" && !!path25[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -6037,11 +6345,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path24, value) {
-        if (isEmptyPath(path24))
+      addIn(path25, value) {
+        if (isEmptyPath(path25))
           this.add(value);
         else {
-          const [key, ...rest] = path24;
+          const [key, ...rest] = path25;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -6055,8 +6363,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path24) {
-        const [key, ...rest] = path24;
+      deleteIn(path25) {
+        const [key, ...rest] = path25;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -6070,8 +6378,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path24, keepScalar) {
-        const [key, ...rest] = path24;
+      getIn(path25, keepScalar) {
+        const [key, ...rest] = path25;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -6089,8 +6397,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path24) {
-        const [key, ...rest] = path24;
+      hasIn(path25) {
+        const [key, ...rest] = path25;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -6100,8 +6408,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path24, value) {
-        const [key, ...rest] = path24;
+      setIn(path25, value) {
+        const [key, ...rest] = path25;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -8613,9 +8921,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path24, value) {
+      addIn(path25, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path24, value);
+          this.contents.addIn(path25, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -8690,14 +8998,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path24) {
-        if (Collection.isEmptyPath(path24)) {
+      deleteIn(path25) {
+        if (Collection.isEmptyPath(path25)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path24) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path25) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -8712,10 +9020,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path24, keepScalar) {
-        if (Collection.isEmptyPath(path24))
+      getIn(path25, keepScalar) {
+        if (Collection.isEmptyPath(path25))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path24, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path25, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -8726,10 +9034,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path24) {
-        if (Collection.isEmptyPath(path24))
+      hasIn(path25) {
+        if (Collection.isEmptyPath(path25))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path24) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path25) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -8746,13 +9054,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path24, value) {
-        if (Collection.isEmptyPath(path24)) {
+      setIn(path25, value) {
+        if (Collection.isEmptyPath(path25)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path24), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path25), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path24, value);
+          this.contents.setIn(path25, value);
         }
       }
       /**
@@ -10709,9 +11017,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path24) => {
+    visit.itemAtPath = (cst, path25) => {
       let item = cst;
-      for (const [field, index] of path24) {
+      for (const [field, index] of path25) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -10720,23 +11028,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path24) => {
-      const parent = visit.itemAtPath(cst, path24.slice(0, -1));
-      const field = path24[path24.length - 1][0];
+    visit.parentCollection = (cst, path25) => {
+      const parent = visit.itemAtPath(cst, path25.slice(0, -1));
+      const field = path25[path25.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path24, item, visitor) {
-      let ctrl = visitor(item, path24);
+    function _visit(path25, item, visitor) {
+      let ctrl = visitor(item, path25);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path24.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path25.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -10747,10 +11055,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path24);
+            ctrl = ctrl(item, path25);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path24) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path25) : ctrl;
     }
     exports2.visit = visit;
   }
@@ -12035,14 +12343,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs29 = this.flowScalar(this.type);
+              const fs30 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start: start2, key: fs29, sep: [] });
+                map.items.push({ start: start2, key: fs30, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs29);
+                this.stack.push(fs30);
               } else {
-                Object.assign(it, { key: fs29, sep: [] });
+                Object.assign(it, { key: fs30, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -12170,13 +12478,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs29 = this.flowScalar(this.type);
+              const fs30 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs29, sep: [] });
+                fc.items.push({ start: [], key: fs30, sep: [] });
               else if (it.sep)
-                this.stack.push(fs29);
+                this.stack.push(fs30);
               else
-                Object.assign(it, { key: fs29, sep: [] });
+                Object.assign(it, { key: fs30, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -12943,7 +13251,7 @@ async function handleRecordingCommand(command, args, target, currentSession) {
           throw new Error(`Unknown format: ${format}. Use "browse" (chain JSON), "replay" (Puppeteer), "playwright" (Playwright Test), or "flow" (YAML).`);
         }
         if (filePath) {
-          fs15.writeFileSync(filePath, output);
+          fs17.writeFileSync(filePath, output);
           return `Exported ${steps.length} steps as ${format}: ${filePath}`;
         }
         return output;
@@ -12968,7 +13276,7 @@ async function handleRecordingCommand(command, args, target, currentSession) {
         const { formatAsHar: formatAsHar2 } = await Promise.resolve().then(() => (init_har(), har_exports));
         const har = formatAsHar2(sessionBuffers.networkBuffer, recording.startTime);
         const harPath = args[1] || (currentSession ? `${currentSession.outputDir}/recording.har` : `${LOCAL_DIR2}/browse-recording.har`);
-        fs15.writeFileSync(harPath, JSON.stringify(har, null, 2));
+        fs17.writeFileSync(harPath, JSON.stringify(har, null, 2));
         const entryCount = har.log.entries.length;
         return `HAR saved: ${harPath} (${entryCount} entries)`;
       }
@@ -13004,11 +13312,11 @@ async function handleRecordingCommand(command, args, target, currentSession) {
       throw new Error(`Unknown recording command: ${command}`);
   }
 }
-var fs15, LOCAL_DIR2;
+var fs17, LOCAL_DIR2;
 var init_recording = __esm({
   "src/commands/meta/recording.ts"() {
     "use strict";
-    fs15 = __toESM(require("fs"), 1);
+    fs17 = __toESM(require("fs"), 1);
     LOCAL_DIR2 = process.env.BROWSE_LOCAL_DIR || "/tmp";
   }
 });
@@ -13032,20 +13340,20 @@ async function saveSessionState(sessionDir, context, encryptionKey) {
     } else {
       content = json;
     }
-    fs16.mkdirSync(sessionDir, { recursive: true });
-    fs16.writeFileSync(path12.join(sessionDir, STATE_FILENAME), content, { mode: 384 });
+    fs18.mkdirSync(sessionDir, { recursive: true });
+    fs18.writeFileSync(path14.join(sessionDir, STATE_FILENAME), content, { mode: 384 });
   } catch (err) {
     console.log(`[session-persist] Warning: failed to save state: ${err.message}`);
   }
 }
 async function loadSessionState(sessionDir, context, encryptionKey) {
-  const statePath = path12.join(sessionDir, STATE_FILENAME);
-  if (!fs16.existsSync(statePath)) {
+  const statePath = path14.join(sessionDir, STATE_FILENAME);
+  if (!fs18.existsSync(statePath)) {
     return false;
   }
   let stateData;
   try {
-    const raw = fs16.readFileSync(statePath, "utf-8");
+    const raw = fs18.readFileSync(statePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.encrypted) {
       if (!encryptionKey) {
@@ -13101,24 +13409,24 @@ async function loadSessionState(sessionDir, context, encryptionKey) {
   }
 }
 function hasPersistedState(sessionDir) {
-  return fs16.existsSync(path12.join(sessionDir, STATE_FILENAME));
+  return fs18.existsSync(path14.join(sessionDir, STATE_FILENAME));
 }
 function cleanOldStates(localDir, maxAgeDays) {
   const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1e3;
   const now = Date.now();
   let deleted = 0;
-  const statesDir = path12.join(localDir, "states");
-  if (fs16.existsSync(statesDir)) {
+  const statesDir = path14.join(localDir, "states");
+  if (fs18.existsSync(statesDir)) {
     try {
-      const entries = fs16.readdirSync(statesDir);
+      const entries = fs18.readdirSync(statesDir);
       for (const entry of entries) {
         if (!entry.endsWith(".json")) continue;
-        const filePath = path12.join(statesDir, entry);
+        const filePath = path14.join(statesDir, entry);
         try {
-          const stat = fs16.statSync(filePath);
+          const stat = fs18.statSync(filePath);
           if (!stat.isFile()) continue;
           if (now - stat.mtimeMs > maxAgeMs) {
-            fs16.unlinkSync(filePath);
+            fs18.unlinkSync(filePath);
             deleted++;
           }
         } catch (_) {
@@ -13127,23 +13435,23 @@ function cleanOldStates(localDir, maxAgeDays) {
     } catch (_) {
     }
   }
-  const sessionsDir = path12.join(localDir, "sessions");
-  if (fs16.existsSync(sessionsDir)) {
+  const sessionsDir = path14.join(localDir, "sessions");
+  if (fs18.existsSync(sessionsDir)) {
     try {
-      const sessionDirs = fs16.readdirSync(sessionsDir);
+      const sessionDirs = fs18.readdirSync(sessionsDir);
       for (const dir of sessionDirs) {
-        const dirPath = path12.join(sessionsDir, dir);
+        const dirPath = path14.join(sessionsDir, dir);
         try {
-          const dirStat = fs16.statSync(dirPath);
+          const dirStat = fs18.statSync(dirPath);
           if (!dirStat.isDirectory()) continue;
         } catch (_) {
           continue;
         }
-        const statePath = path12.join(dirPath, STATE_FILENAME);
+        const statePath = path14.join(dirPath, STATE_FILENAME);
         try {
-          const stat = fs16.statSync(statePath);
+          const stat = fs18.statSync(statePath);
           if (now - stat.mtimeMs > maxAgeMs) {
-            fs16.unlinkSync(statePath);
+            fs18.unlinkSync(statePath);
             deleted++;
           }
         } catch (_) {
@@ -13154,12 +13462,12 @@ function cleanOldStates(localDir, maxAgeDays) {
   }
   return { deleted };
 }
-var fs16, path12, STATE_FILENAME;
+var fs18, path14, STATE_FILENAME;
 var init_persist = __esm({
   "src/session/persist.ts"() {
     "use strict";
-    fs16 = __toESM(require("fs"), 1);
-    path12 = __toESM(require("path"), 1);
+    fs18 = __toESM(require("fs"), 1);
+    path14 = __toESM(require("path"), 1);
     init_encryption();
     STATE_FILENAME = "state.json";
   }
@@ -13594,7 +13902,7 @@ async function handleSessionsCommand(command, args, bm, sessionManager2, current
           const lines = entries.map(
             (e) => `[${new Date(e.timestamp).toISOString()}] [${e.level}] ${e.text}`
           ).join("\n") + "\n";
-          fs17.appendFileSync(consolePath, lines);
+          fs19.appendFileSync(consolePath, lines);
           buffers.lastConsoleFlushed = buffers.consoleTotalAdded;
         }
         const newNetworkCount = buffers.networkTotalAdded - buffers.lastNetworkFlushed;
@@ -13604,7 +13912,7 @@ async function handleSessionsCommand(command, args, bm, sessionManager2, current
           const lines = entries.map(
             (e) => `[${new Date(e.timestamp).toISOString()}] ${e.method} ${e.url} \u2192 ${e.status || "pending"} (${e.duration || "?"}ms, ${e.size || "?"}B)`
           ).join("\n") + "\n";
-          fs17.appendFileSync(networkPath, lines);
+          fs19.appendFileSync(networkPath, lines);
           buffers.lastNetworkFlushed = buffers.networkTotalAdded;
         }
       }
@@ -13620,22 +13928,22 @@ async function handleSessionsCommand(command, args, bm, sessionManager2, current
       const statesDir = `${LOCAL_DIR3}/states`;
       const statePath = `${statesDir}/${name}.json`;
       if (subcommand === "list") {
-        if (!fs17.existsSync(statesDir)) return "(no saved states)";
-        const files = fs17.readdirSync(statesDir).filter((f) => f.endsWith(".json"));
+        if (!fs19.existsSync(statesDir)) return "(no saved states)";
+        const files = fs19.readdirSync(statesDir).filter((f) => f.endsWith(".json"));
         if (files.length === 0) return "(no saved states)";
         const lines = [];
         for (const file of files) {
           const fp = `${statesDir}/${file}`;
-          const stat = fs17.statSync(fp);
+          const stat = fs19.statSync(fp);
           lines.push(`  ${file.replace(".json", "")}  ${stat.size}B  ${new Date(stat.mtimeMs).toISOString()}`);
         }
         return lines.join("\n");
       }
       if (subcommand === "show") {
-        if (!fs17.existsSync(statePath)) {
+        if (!fs19.existsSync(statePath)) {
           throw new Error(`State file not found: ${statePath}`);
         }
-        const data = JSON.parse(fs17.readFileSync(statePath, "utf-8"));
+        const data = JSON.parse(fs19.readFileSync(statePath, "utf-8"));
         const cookieCount = data.cookies?.length || 0;
         const originCount = data.origins?.length || 0;
         const storageItems = (data.origins || []).reduce((sum, o) => sum + (o.localStorage?.length || 0), 0);
@@ -13660,15 +13968,15 @@ async function handleSessionsCommand(command, args, bm, sessionManager2, current
         const context = bm.getContext();
         if (!context) throw new Error("No browser context");
         const state = await context.storageState();
-        fs17.mkdirSync(statesDir, { recursive: true });
-        fs17.writeFileSync(statePath, JSON.stringify(state, null, 2), { mode: 384 });
+        fs19.mkdirSync(statesDir, { recursive: true });
+        fs19.writeFileSync(statePath, JSON.stringify(state, null, 2), { mode: 384 });
         return `State saved: ${statePath}`;
       }
       if (subcommand === "load") {
-        if (!fs17.existsSync(statePath)) {
+        if (!fs19.existsSync(statePath)) {
           throw new Error(`State file not found: ${statePath}. Run "browse state save ${name}" first.`);
         }
-        const stateData = JSON.parse(fs17.readFileSync(statePath, "utf-8"));
+        const stateData = JSON.parse(fs19.readFileSync(statePath, "utf-8"));
         const context = bm.getContext();
         if (!context) throw new Error("No browser context");
         const warnings = [];
@@ -13721,12 +14029,12 @@ ${snapshot}`;
       throw new Error(`Unknown sessions command: ${command}`);
   }
 }
-var fs17, LOCAL_DIR3;
+var fs19, LOCAL_DIR3;
 var init_sessions = __esm({
   "src/commands/meta/sessions.ts"() {
     "use strict";
     init_sanitize();
-    fs17 = __toESM(require("fs"), 1);
+    fs19 = __toESM(require("fs"), 1);
     LOCAL_DIR3 = process.env.BROWSE_LOCAL_DIR || "/tmp";
   }
 });
@@ -14057,11 +14365,11 @@ var init_lib = __esm({
           }
         }
       },
-      addToPath: function addToPath(path24, added, removed, oldPosInc, options) {
-        var last = path24.lastComponent;
+      addToPath: function addToPath(path25, added, removed, oldPosInc, options) {
+        var last = path25.lastComponent;
         if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
           return {
-            oldPos: path24.oldPos + oldPosInc,
+            oldPos: path25.oldPos + oldPosInc,
             lastComponent: {
               count: last.count + 1,
               added,
@@ -14071,7 +14379,7 @@ var init_lib = __esm({
           };
         } else {
           return {
-            oldPos: path24.oldPos + oldPosInc,
+            oldPos: path25.oldPos + oldPosInc,
             lastComponent: {
               count: 1,
               added,
@@ -14129,7 +14437,7 @@ var init_lib = __esm({
       tokenize: function tokenize(value) {
         return Array.from(value);
       },
-      join: function join13(chars) {
+      join: function join15(chars) {
         return chars.join("");
       },
       postProcess: function postProcess(changeObjects) {
@@ -19690,19 +19998,19 @@ __export(detection_exports, {
   detectStack: () => detectStack
 });
 function loadCustomSignatures(localDir) {
-  const detectionDir = path13.join(localDir, "detections");
-  if (!fs18.existsSync(detectionDir)) return [];
+  const detectionDir = path15.join(localDir, "detections");
+  if (!fs20.existsSync(detectionDir)) return [];
   const sigs = [];
   let entries;
   try {
-    entries = fs18.readdirSync(detectionDir).filter((f) => f.endsWith(".json"));
+    entries = fs20.readdirSync(detectionDir).filter((f) => f.endsWith(".json"));
   } catch {
     return [];
   }
   for (const entry of entries) {
-    const filePath = path13.join(detectionDir, entry);
+    const filePath = path15.join(detectionDir, entry);
     try {
-      const raw = fs18.readFileSync(filePath, "utf-8");
+      const raw = fs20.readFileSync(filePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed == null || typeof parsed !== "object" || parsed.version !== 1 || typeof parsed.name !== "string" || typeof parsed.detect !== "string") {
         process.stderr.write(
@@ -19828,15 +20136,15 @@ async function detectStack(page, networkEntries, localDir) {
   const thirdParty = buildThirdPartyInventory(page, networkEntries ?? []);
   return { frameworks, saas, infrastructure, thirdParty, custom };
 }
-var fs18, path13, THIRD_PARTY_DOMAINS;
+var fs20, path15, THIRD_PARTY_DOMAINS;
 var init_detection = __esm({
   "src/detection/index.ts"() {
     "use strict";
     init_frameworks();
     init_saas();
     init_infrastructure();
-    fs18 = __toESM(require("fs"), 1);
-    path13 = __toESM(require("path"), 1);
+    fs20 = __toESM(require("fs"), 1);
+    path15 = __toESM(require("path"), 1);
     THIRD_PARTY_DOMAINS = {
       // Analytics
       "google-analytics.com": "analytics",
@@ -21918,35 +22226,35 @@ __export(persist_exports2, {
   saveAudit: () => saveAudit
 });
 function auditsDir(localDir) {
-  return path14.join(localDir, "audits");
+  return path16.join(localDir, "audits");
 }
 function auditPath(localDir, name) {
-  return path14.join(auditsDir(localDir), `${sanitizeName(name)}.json`);
+  return path16.join(auditsDir(localDir), `${sanitizeName(name)}.json`);
 }
 function saveAudit(localDir, name, report) {
   const dir = auditsDir(localDir);
-  fs19.mkdirSync(dir, { recursive: true });
+  fs21.mkdirSync(dir, { recursive: true });
   const filePath = auditPath(localDir, name);
-  fs19.writeFileSync(filePath, JSON.stringify(report, null, 2), { mode: 384 });
+  fs21.writeFileSync(filePath, JSON.stringify(report, null, 2), { mode: 384 });
   return filePath;
 }
 function loadAudit(localDir, name) {
   const filePath = auditPath(localDir, name);
-  if (!fs19.existsSync(filePath)) {
+  if (!fs21.existsSync(filePath)) {
     throw new Error(
       `Audit not found: ${filePath}. Run "browse perf-audit save ${name}" first.`
     );
   }
-  return JSON.parse(fs19.readFileSync(filePath, "utf-8"));
+  return JSON.parse(fs21.readFileSync(filePath, "utf-8"));
 }
 function listAudits(localDir) {
   const dir = auditsDir(localDir);
-  if (!fs19.existsSync(dir)) return [];
-  const files = fs19.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  if (!fs21.existsSync(dir)) return [];
+  const files = fs21.readdirSync(dir).filter((f) => f.endsWith(".json"));
   if (files.length === 0) return [];
   const entries = files.map((file) => {
-    const fp = path14.join(dir, file);
-    const stat = fs19.statSync(fp);
+    const fp = path16.join(dir, file);
+    const stat = fs21.statSync(fp);
     return {
       name: file.replace(".json", ""),
       sizeBytes: stat.size,
@@ -21958,19 +22266,19 @@ function listAudits(localDir) {
 }
 function deleteAudit(localDir, name) {
   const filePath = auditPath(localDir, name);
-  if (!fs19.existsSync(filePath)) {
+  if (!fs21.existsSync(filePath)) {
     throw new Error(
       `Audit not found: ${filePath}. Nothing to delete.`
     );
   }
-  fs19.unlinkSync(filePath);
+  fs21.unlinkSync(filePath);
 }
-var fs19, path14;
+var fs21, path16;
 var init_persist2 = __esm({
   "src/perf-audit/persist.ts"() {
     "use strict";
-    fs19 = __toESM(require("fs"), 1);
-    path14 = __toESM(require("path"), 1);
+    fs21 = __toESM(require("fs"), 1);
+    path16 = __toESM(require("path"), 1);
     init_sanitize();
   }
 });
@@ -23328,7 +23636,7 @@ All budgets met.`;
           }
           return "OK";
         }
-        await new Promise((resolve9) => setTimeout(resolve9, 100));
+        await new Promise((resolve10) => setTimeout(resolve10, 100));
       }
       const failures = lastResults.filter((r2) => !r2.passed);
       throw new Error(
@@ -23417,12 +23725,12 @@ async function autoDetectSelector(page, field) {
   }
   throw new Error("Could not auto-detect submit button.");
 }
-var fs20, path15, AuthVault;
+var fs22, path17, AuthVault;
 var init_auth_vault = __esm({
   "src/security/auth-vault.ts"() {
     "use strict";
-    fs20 = __toESM(require("fs"), 1);
-    path15 = __toESM(require("path"), 1);
+    fs22 = __toESM(require("fs"), 1);
+    path17 = __toESM(require("path"), 1);
     init_constants();
     init_encryption();
     init_sanitize();
@@ -23430,11 +23738,11 @@ var init_auth_vault = __esm({
       authDir;
       encryptionKey;
       constructor(localDir) {
-        this.authDir = path15.join(localDir, "auth");
+        this.authDir = path17.join(localDir, "auth");
         this.encryptionKey = resolveEncryptionKey(localDir);
       }
       save(name, url, username, password, selectors) {
-        fs20.mkdirSync(this.authDir, { recursive: true });
+        fs22.mkdirSync(this.authDir, { recursive: true });
         const { ciphertext, iv, authTag } = encrypt(password, this.encryptionKey);
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const credential = {
@@ -23451,15 +23759,15 @@ var init_auth_vault = __esm({
           createdAt: now,
           updatedAt: now
         };
-        const filePath = path15.join(this.authDir, `${sanitizeName(name)}.json`);
-        fs20.writeFileSync(filePath, JSON.stringify(credential, null, 2), { mode: 384 });
+        const filePath = path17.join(this.authDir, `${sanitizeName(name)}.json`);
+        fs22.writeFileSync(filePath, JSON.stringify(credential, null, 2), { mode: 384 });
       }
       load(name) {
-        const filePath = path15.join(this.authDir, `${sanitizeName(name)}.json`);
-        if (!fs20.existsSync(filePath)) {
+        const filePath = path17.join(this.authDir, `${sanitizeName(name)}.json`);
+        if (!fs22.existsSync(filePath)) {
           throw new Error(`Credential "${name}" not found. Run "browse auth list" to see saved credentials.`);
         }
-        return JSON.parse(fs20.readFileSync(filePath, "utf-8"));
+        return JSON.parse(fs22.readFileSync(filePath, "utf-8"));
       }
       async login(name, bm) {
         const cred = this.load(name);
@@ -23480,11 +23788,11 @@ var init_auth_vault = __esm({
         return `Logged in as ${cred.username} at ${page.url()}`;
       }
       list() {
-        if (!fs20.existsSync(this.authDir)) return [];
-        const files = fs20.readdirSync(this.authDir).filter((f) => f.endsWith(".json"));
+        if (!fs22.existsSync(this.authDir)) return [];
+        const files = fs22.readdirSync(this.authDir).filter((f) => f.endsWith(".json"));
         return files.map((f) => {
           try {
-            const data = JSON.parse(fs20.readFileSync(path15.join(this.authDir, f), "utf-8"));
+            const data = JSON.parse(fs22.readFileSync(path17.join(this.authDir, f), "utf-8"));
             return {
               name: data.name,
               url: data.url,
@@ -23498,11 +23806,11 @@ var init_auth_vault = __esm({
         }).filter(Boolean);
       }
       delete(name) {
-        const filePath = path15.join(this.authDir, `${sanitizeName(name)}.json`);
-        if (!fs20.existsSync(filePath)) {
+        const filePath = path17.join(this.authDir, `${sanitizeName(name)}.json`);
+        if (!fs22.existsSync(filePath)) {
           throw new Error(`Credential "${name}" not found.`);
         }
-        fs20.unlinkSync(filePath);
+        fs22.unlinkSync(filePath);
       }
     };
   }
@@ -23639,20 +23947,20 @@ __export(policy_exports, {
 function findFileUpward(filename) {
   let dir = process.cwd();
   for (let i = 0; i < 20; i++) {
-    const candidate = path16.join(dir, filename);
-    if (fs21.existsSync(candidate)) return candidate;
-    const parent = path16.dirname(dir);
+    const candidate = path18.join(dir, filename);
+    if (fs23.existsSync(candidate)) return candidate;
+    const parent = path18.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return null;
 }
-var fs21, path16, PolicyChecker;
+var fs23, path18, PolicyChecker;
 var init_policy = __esm({
   "src/security/policy.ts"() {
     "use strict";
-    fs21 = __toESM(require("fs"), 1);
-    path16 = __toESM(require("path"), 1);
+    fs23 = __toESM(require("fs"), 1);
+    path18 = __toESM(require("path"), 1);
     PolicyChecker = class {
       filePath = null;
       lastMtime = 0;
@@ -23671,10 +23979,10 @@ var init_policy = __esm({
       reload() {
         if (!this.filePath) return;
         try {
-          const stat = fs21.statSync(this.filePath);
+          const stat = fs23.statSync(this.filePath);
           if (stat.mtimeMs === this.lastMtime) return;
           this.lastMtime = stat.mtimeMs;
-          const raw = fs21.readFileSync(this.filePath, "utf-8");
+          const raw = fs23.readFileSync(this.filePath, "utf-8");
           this.policy = JSON.parse(raw);
         } catch {
         }
@@ -23851,110 +24159,6 @@ var init_buffers = __esm({
   }
 });
 
-// src/app/macos/bridge.ts
-var bridge_exports3 = {};
-__export(bridge_exports3, {
-  createMacOSBridge: () => createMacOSBridge,
-  ensureMacOSBridge: () => ensureMacOSBridge,
-  resolveBridgePath: () => resolveBridgePath
-});
-function resolveBridgePath() {
-  const candidates = [
-    // 1. Local dev build
-    path17.resolve(__dirname_bridge, "../../../browse-ax/.build/release/browse-ax"),
-    path17.resolve(__dirname_bridge, "../../../browse-ax/.build/debug/browse-ax"),
-    // 2. Installed alongside source (bin/ at project root)
-    path17.resolve(__dirname_bridge, "../../bin/browse-ax"),
-    // 3. Bundled build (dist/browse.cjs → ../bin/)
-    path17.resolve(__dirname_bridge, "../bin/browse-ax")
-  ];
-  for (const p of candidates) {
-    if (fs22.existsSync(p)) return p;
-  }
-  const lazyPath = path17.join(
-    process.env.BROWSE_LOCAL_DIR || path17.join(process.cwd(), ".browse"),
-    "bin",
-    "browse-ax"
-  );
-  if (fs22.existsSync(lazyPath)) return lazyPath;
-  throw new Error(
-    "browse-ax binary not found. Run: browse enable macos\nOr build manually: cd browse-ax && swift build -c release"
-  );
-}
-async function ensureMacOSBridge() {
-  if (process.platform !== "darwin") {
-    throw new Error("App automation requires macOS (uses Accessibility API)");
-  }
-  return resolveBridgePath();
-}
-async function execBridge(bridgePath, args) {
-  return new Promise((resolve9, reject) => {
-    const proc = (0, import_child_process9.spawn)(bridgePath, args, {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    const chunks = [];
-    const errChunks = [];
-    proc.stdout.on("data", (c) => chunks.push(c));
-    proc.stderr.on("data", (c) => errChunks.push(c));
-    proc.on("close", (code) => {
-      const stdout = Buffer.concat(chunks).toString("utf-8").trim();
-      const stderr = Buffer.concat(errChunks).toString("utf-8").trim();
-      if (code !== 0) {
-        try {
-          const err = JSON.parse(stderr || stdout);
-          reject(new Error(err.error || `Bridge exited with code ${code}`));
-        } catch {
-          reject(new Error(stderr || `Bridge exited with code ${code}`));
-        }
-        return;
-      }
-      try {
-        resolve9(JSON.parse(stdout));
-      } catch {
-        reject(new Error(`Invalid bridge output: ${stdout.slice(0, 200)}`));
-      }
-    });
-  });
-}
-function createMacOSBridge(bridgePath, pid) {
-  const base = ["--pid", String(pid)];
-  return {
-    async tree() {
-      return execBridge(bridgePath, [...base, "tree"]);
-    },
-    async action(nodePath, actionName) {
-      return execBridge(bridgePath, [...base, "action", JSON.stringify(nodePath), actionName]);
-    },
-    async setValue(nodePath, value) {
-      return execBridge(bridgePath, [...base, "set-value", JSON.stringify(nodePath), value]);
-    },
-    async type(text) {
-      return execBridge(bridgePath, [...base, "type", text]);
-    },
-    async press(key) {
-      return execBridge(bridgePath, [...base, "press", key]);
-    },
-    async screenshot(outputPath) {
-      return execBridge(bridgePath, [...base, "screenshot", outputPath]);
-    },
-    async state() {
-      return execBridge(bridgePath, [...base, "state"]);
-    }
-  };
-}
-var import_child_process9, path17, fs22, import_url6, __filename_bridge2, __dirname_bridge;
-var init_bridge3 = __esm({
-  "src/app/macos/bridge.ts"() {
-    "use strict";
-    import_child_process9 = require("child_process");
-    path17 = __toESM(require("path"), 1);
-    fs22 = __toESM(require("fs"), 1);
-    import_url6 = require("url");
-    __filename_bridge2 = (0, import_url6.fileURLToPath)(__import_meta_url);
-    __dirname_bridge = path17.dirname(__filename_bridge2);
-  }
-});
-
 // src/commands/meta/system.ts
 async function handleSystemCommand(command, args, target, shutdown2, sessionManager2, currentSession, lifecycle) {
   switch (command) {
@@ -24056,7 +24260,7 @@ async function handleSystemCommand(command, args, target, shutdown2, sessionMana
       return results.join("\n\n");
     }
     case "doctor": {
-      const { execSync: execSync7 } = await import("child_process");
+      const { execSync: execSync8 } = await import("child_process");
       const platformArg = args.find((a) => a.startsWith("--platform="))?.split("=")[1] || (args.indexOf("--platform") !== -1 ? args[args.indexOf("--platform") + 1] : "");
       const lines = [];
       lines.push(`Node: ${process.version}`);
@@ -24086,7 +24290,7 @@ async function handleSystemCommand(command, args, target, shutdown2, sessionMana
         lines.push("");
         lines.push("--- Android ---");
         try {
-          const adbVersion = execSync7("adb version", { encoding: "utf-8", timeout: 5e3 }).split("\n")[0].trim();
+          const adbVersion = execSync8("adb version", { encoding: "utf-8", timeout: 5e3 }).split("\n")[0].trim();
           lines.push(`adb: ${adbVersion}`);
         } catch {
           lines.push("adb: NOT FOUND \u2014 install Android SDK platform-tools and add to PATH");
@@ -24094,7 +24298,7 @@ async function handleSystemCommand(command, args, target, shutdown2, sessionMana
           if (platformArg === "android") return lines.join("\n");
         }
         try {
-          const devicesOut = execSync7("adb devices", { encoding: "utf-8", timeout: 5e3 });
+          const devicesOut = execSync8("adb devices", { encoding: "utf-8", timeout: 5e3 });
           const deviceLines = devicesOut.split("\n").slice(1).map((l) => l.trim()).filter((l) => l.length > 0);
           const booted = deviceLines.filter((l) => l.endsWith("	device"));
           const other = deviceLines.filter((l) => !l.endsWith("	device"));
@@ -24111,8 +24315,8 @@ async function handleSystemCommand(command, args, target, shutdown2, sessionMana
           lines.push("Devices: could not query (adb failed)");
         }
         try {
-          execSync7("emulator -list-avds", { encoding: "utf-8", timeout: 5e3, stdio: ["ignore", "pipe", "pipe"] });
-          const avds = execSync7("emulator -list-avds", { encoding: "utf-8", timeout: 5e3 }).trim();
+          execSync8("emulator -list-avds", { encoding: "utf-8", timeout: 5e3, stdio: ["ignore", "pipe", "pipe"] });
+          const avds = execSync8("emulator -list-avds", { encoding: "utf-8", timeout: 5e3 }).trim();
           if (avds) {
             lines.push(`AVDs: ${avds.split("\n").join(", ")}`);
           } else {
@@ -24122,13 +24326,13 @@ async function handleSystemCommand(command, args, target, shutdown2, sessionMana
           lines.push("Emulator: not found (optional \u2014 only needed to start AVDs from CLI)");
         }
         try {
-          const fs29 = await import("fs");
-          const path24 = await import("path");
-          const localBuild = path24.resolve(__dirname, "../../../browse-android/app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk");
-          const installed = path24.resolve(__dirname, "../../bin/browse-android.apk");
-          if (fs29.existsSync(localBuild)) {
+          const fs30 = await import("fs");
+          const path25 = await import("path");
+          const localBuild = path25.resolve(__dirname, "../../../browse-android/app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk");
+          const installed = path25.resolve(__dirname, "../../bin/browse-android.apk");
+          if (fs30.existsSync(localBuild)) {
             lines.push(`Driver APK: ${localBuild}`);
-          } else if (fs29.existsSync(installed)) {
+          } else if (fs30.existsSync(installed)) {
             lines.push(`Driver APK: ${installed}`);
           } else {
             lines.push("Driver APK: NOT FOUND");
@@ -24141,9 +24345,9 @@ async function handleSystemCommand(command, args, target, shutdown2, sessionMana
       return lines.join("\n");
     }
     case "upgrade": {
-      const { execSync: execSync7 } = await import("child_process");
+      const { execSync: execSync8 } = await import("child_process");
       try {
-        const output = execSync7("npm update -g @ulpi/browse 2>&1", { encoding: "utf-8", timeout: 3e4 });
+        const output = execSync8("npm update -g @ulpi/browse 2>&1", { encoding: "utf-8", timeout: 3e4 });
         return `Upgrade complete.
 ${output.trim()}`;
       } catch (err) {
@@ -24450,21 +24654,21 @@ var init_refs = __esm({
 function getProfileDir(localDir, name) {
   const sanitized = sanitizeName(name);
   if (!sanitized) throw new Error("Invalid profile name");
-  return path18.join(localDir, "profiles", sanitized);
+  return path19.join(localDir, "profiles", sanitized);
 }
 function listProfiles(localDir) {
-  const profilesDir = path18.join(localDir, "profiles");
-  if (!fs23.existsSync(profilesDir)) return [];
-  return fs23.readdirSync(profilesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
-    const dir = path18.join(profilesDir, d.name);
-    const stat = fs23.statSync(dir);
+  const profilesDir = path19.join(localDir, "profiles");
+  if (!fs24.existsSync(profilesDir)) return [];
+  return fs24.readdirSync(profilesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
+    const dir = path19.join(profilesDir, d.name);
+    const stat = fs24.statSync(dir);
     let totalSize = 0;
     try {
-      const files = fs23.readdirSync(dir, { recursive: true, withFileTypes: true });
+      const files = fs24.readdirSync(dir, { recursive: true, withFileTypes: true });
       for (const f of files) {
         if (f.isFile()) {
           try {
-            totalSize += fs23.statSync(path18.join(f.parentPath || f.path || dir, f.name)).size;
+            totalSize += fs24.statSync(path19.join(f.parentPath || f.path || dir, f.name)).size;
           } catch {
           }
         }
@@ -24481,15 +24685,15 @@ function listProfiles(localDir) {
 }
 function deleteProfile(localDir, name) {
   const dir = getProfileDir(localDir, name);
-  if (!fs23.existsSync(dir)) throw new Error(`Profile "${name}" not found`);
-  fs23.rmSync(dir, { recursive: true, force: true });
+  if (!fs24.existsSync(dir)) throw new Error(`Profile "${name}" not found`);
+  fs24.rmSync(dir, { recursive: true, force: true });
 }
-var path18, fs23;
+var path19, fs24;
 var init_profiles = __esm({
   "src/browser/profiles.ts"() {
     "use strict";
-    path18 = __toESM(require("path"), 1);
-    fs23 = __toESM(require("fs"), 1);
+    path19 = __toESM(require("path"), 1);
+    fs24 = __toESM(require("fs"), 1);
     init_sanitize();
   }
 });
@@ -24663,9 +24867,9 @@ var init_manager = __esm({
           });
         } catch (err) {
           if (err.message?.includes("Failed to launch") || err.message?.includes("Target closed")) {
-            const fs29 = await import("fs");
+            const fs30 = await import("fs");
             console.error(`[browse] Profile directory corrupted, recreating: ${profileDir}`);
-            fs29.rmSync(profileDir, { recursive: true, force: true });
+            fs30.rmSync(profileDir, { recursive: true, force: true });
             context = await import_playwright2.chromium.launchPersistentContext(profileDir, {
               headless: process.env.BROWSE_HEADED !== "1",
               viewport: { width: 1920, height: 1080 }
@@ -25393,8 +25597,8 @@ var init_manager = __esm({
       // ─── Video Recording ──────────────────────────────────────
       async startVideoRecording(dir) {
         if (this.videoRecording) throw new Error("Video recording already active");
-        const fs29 = await import("fs");
-        fs29.mkdirSync(dir, { recursive: true });
+        const fs30 = await import("fs");
+        fs30.mkdirSync(dir, { recursive: true });
         this.videoRecording = { dir, startedAt: Date.now() };
         const viewport = this.currentDevice?.viewport || { width: 1920, height: 1080 };
         await this.recreateContext({
@@ -25691,10 +25895,10 @@ __export(react_devtools_exports, {
   requireReact: () => requireReact
 });
 async function ensureHook() {
-  if (fs24.existsSync(HOOK_PATH)) {
-    return fs24.readFileSync(HOOK_PATH, "utf8");
+  if (fs25.existsSync(HOOK_PATH)) {
+    return fs25.readFileSync(HOOK_PATH, "utf8");
   }
-  fs24.mkdirSync(CACHE_DIR, { recursive: true });
+  fs25.mkdirSync(CACHE_DIR, { recursive: true });
   const res = await fetch(HOOK_URL);
   if (!res.ok) {
     throw new Error(
@@ -25703,7 +25907,7 @@ Manual fallback: npm install -g react-devtools-core, then copy installHook.js to
     );
   }
   const script = await res.text();
-  fs24.writeFileSync(HOOK_PATH, script);
+  fs25.writeFileSync(HOOK_PATH, script);
   return script;
 }
 async function injectHook(bm) {
@@ -25850,15 +26054,15 @@ async function getSuspense(bm, page) {
     if (!roots || roots.size === 0) return "No fiber roots found";
     const root = roots.values().next().value;
     const boundaries = [];
-    const walk = (fiber, path24) => {
+    const walk = (fiber, path25) => {
       if (!fiber) return;
       if (fiber.tag === 13) {
         const resolved = fiber.memoizedState === null;
-        const parent = path24.length > 0 ? path24[path24.length - 1] : "root";
+        const parent = path25.length > 0 ? path25[path25.length - 1] : "root";
         boundaries.push(`Suspense in ${parent} \u2014 ${resolved ? "resolved (children visible)" : "pending (showing fallback)"}`);
       }
       const name = fiber.type?.displayName || fiber.type?.name || null;
-      const newPath = name ? [...path24, name] : path24;
+      const newPath = name ? [...path25, name] : path25;
       let child = fiber.child;
       while (child) {
         walk(child, newPath);
@@ -26037,15 +26241,15 @@ async function getContext(bm, page, selector) {
   await handle.dispose();
   return result;
 }
-var fs24, path19, os3, CACHE_DIR, HOOK_PATH, HOOK_URL;
+var fs25, path20, os4, CACHE_DIR, HOOK_PATH, HOOK_URL;
 var init_react_devtools = __esm({
   "src/browser/react-devtools.ts"() {
     "use strict";
-    fs24 = __toESM(require("fs"), 1);
-    path19 = __toESM(require("path"), 1);
-    os3 = __toESM(require("os"), 1);
-    CACHE_DIR = path19.join(os3.homedir(), ".cache", "browse", "react-devtools");
-    HOOK_PATH = path19.join(CACHE_DIR, "installHook.js");
+    fs25 = __toESM(require("fs"), 1);
+    path20 = __toESM(require("path"), 1);
+    os4 = __toESM(require("os"), 1);
+    CACHE_DIR = path20.join(os4.homedir(), ".cache", "browse", "react-devtools");
+    HOOK_PATH = path20.join(CACHE_DIR, "installHook.js");
     HOOK_URL = "https://unpkg.com/react-devtools-core@latest/dist/installHook.js";
   }
 });
@@ -26333,9 +26537,9 @@ function getFlowsDir() {
   const root = findProjectRoot();
   if (config.flowPaths?.length && root) {
     for (const fp of config.flowPaths) {
-      const abs = path20.isAbsolute(fp) ? fp : path20.join(root, fp);
+      const abs = path21.isAbsolute(fp) ? fp : path21.join(root, fp);
       try {
-        fs25.mkdirSync(abs, { recursive: true });
+        fs26.mkdirSync(abs, { recursive: true });
         return abs;
       } catch {
       }
@@ -26343,17 +26547,17 @@ function getFlowsDir() {
   }
   const localDir = process.env.BROWSE_LOCAL_DIR;
   if (localDir) {
-    const dir2 = path20.join(localDir, "flows");
-    fs25.mkdirSync(dir2, { recursive: true });
+    const dir2 = path21.join(localDir, "flows");
+    fs26.mkdirSync(dir2, { recursive: true });
     return dir2;
   }
   if (root) {
-    const dir2 = path20.join(root, ".browse", "flows");
-    fs25.mkdirSync(dir2, { recursive: true });
+    const dir2 = path21.join(root, ".browse", "flows");
+    fs26.mkdirSync(dir2, { recursive: true });
     return dir2;
   }
-  const dir = path20.join(process.cwd(), ".browse", "flows");
-  fs25.mkdirSync(dir, { recursive: true });
+  const dir = path21.join(process.cwd(), ".browse", "flows");
+  fs26.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function validateFlowName(name) {
@@ -26473,18 +26677,18 @@ async function handleFlowsCommand(command, args, target, shutdown2, sessionManag
         }
         const { exportFlowYaml: exportFlowYaml2 } = await Promise.resolve().then(() => (init_record(), record_exports));
         const yamlContent = exportFlowYaml2(steps2);
-        const flowPath = path20.join(getFlowsDir(), `${name}.yaml`);
-        fs25.writeFileSync(flowPath, yamlContent, "utf-8");
+        const flowPath = path21.join(getFlowsDir(), `${name}.yaml`);
+        fs26.writeFileSync(flowPath, yamlContent, "utf-8");
         return `Flow saved: ${flowPath} (${steps2.length} steps)`;
       }
       if (subOrFile === "run") {
         const name = args[1];
         if (!name) throw new Error("Usage: browse flow run <name>");
         validateFlowName(name);
-        const flowPath = path20.join(getFlowsDir(), `${name}.yaml`);
+        const flowPath = path21.join(getFlowsDir(), `${name}.yaml`);
         let content2;
         try {
-          content2 = fs25.readFileSync(flowPath, "utf-8");
+          content2 = fs26.readFileSync(flowPath, "utf-8");
         } catch (err) {
           if (err.code === "ENOENT") {
             throw new Error(`Saved flow not found: "${name}" (looked at ${flowPath})`);
@@ -26497,18 +26701,18 @@ async function handleFlowsCommand(command, args, target, shutdown2, sessionManag
       }
       if (subOrFile === "list") {
         const flowsDir = getFlowsDir();
-        if (!fs25.existsSync(flowsDir)) {
+        if (!fs26.existsSync(flowsDir)) {
           return "No saved flows (directory does not exist yet)";
         }
-        const entries = fs25.readdirSync(flowsDir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml")).sort();
+        const entries = fs26.readdirSync(flowsDir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml")).sort();
         if (entries.length === 0) {
           return "No saved flows";
         }
         const lines = [`Saved flows (${flowsDir}):`];
         for (const entry of entries) {
           const name = entry.replace(/\.(yaml|yml)$/, "");
-          const fullPath = path20.join(flowsDir, entry);
-          const stat = fs25.statSync(fullPath);
+          const fullPath = path21.join(flowsDir, entry);
+          const stat = fs26.statSync(fullPath);
           const mtime = new Date(stat.mtimeMs).toISOString().replace("T", " ").slice(0, 19);
           lines.push(`  ${name}  (${mtime})`);
         }
@@ -26517,7 +26721,7 @@ async function handleFlowsCommand(command, args, target, shutdown2, sessionManag
       const filePath = subOrFile;
       let content;
       try {
-        content = fs25.readFileSync(filePath, "utf-8");
+        content = fs26.readFileSync(filePath, "utf-8");
       } catch (err) {
         if (err.code === "ENOENT") {
           throw new Error(`Flow file not found: ${filePath}`);
@@ -26559,7 +26763,7 @@ async function handleFlowsCommand(command, args, target, shutdown2, sessionManag
           lastError = err.message;
           if (attempt < maxAttempts) {
             if (backoff) {
-              await new Promise((resolve9) => setTimeout(resolve9, delay));
+              await new Promise((resolve10) => setTimeout(resolve10, delay));
               delay *= 2;
             }
             continue;
@@ -26579,7 +26783,7 @@ async function handleFlowsCommand(command, args, target, shutdown2, sessionManag
           );
         }
         if (backoff) {
-          await new Promise((resolve9) => setTimeout(resolve9, delay));
+          await new Promise((resolve10) => setTimeout(resolve10, delay));
           delay *= 2;
         }
       }
@@ -26632,7 +26836,7 @@ async function handleFlowsCommand(command, args, target, shutdown2, sessionManag
           changeSummary = result.summary;
           break;
         }
-        await new Promise((resolve9) => setTimeout(resolve9, POLL_INTERVAL));
+        await new Promise((resolve10) => setTimeout(resolve10, POLL_INTERVAL));
       }
       await page.evaluate((wid) => {
         const info = window[wid];
@@ -26783,13 +26987,13 @@ function parseCommandString(input) {
   }
   return parts;
 }
-var fs25, path20, DEFAULT_MAX_FLOW_DEPTH, flowDepthMap, sessionlessSentinel;
+var fs26, path21, DEFAULT_MAX_FLOW_DEPTH, flowDepthMap, sessionlessSentinel;
 var init_flows = __esm({
   "src/commands/meta/flows.ts"() {
     "use strict";
     init_config();
-    fs25 = __toESM(require("fs"), 1);
-    path20 = __toESM(require("path"), 1);
+    fs26 = __toESM(require("fs"), 1);
+    path21 = __toESM(require("path"), 1);
     DEFAULT_MAX_FLOW_DEPTH = 10;
     flowDepthMap = /* @__PURE__ */ new WeakMap();
     sessionlessSentinel = {};
@@ -26800,7 +27004,7 @@ var init_flows = __esm({
 async function handleSimCommand(command, args, bm, shutdown2, sessionManager2, currentSession) {
   const sub = args[0];
   if (!sub || !["start", "stop", "status"].includes(sub)) {
-    throw new Error("Usage: browse sim start --platform ios|android [--device <name>] [--app <id>] [--visible] | stop | status");
+    throw new Error("Usage: browse sim start --platform ios|android [--device <name>] [--app <id-or-path>] [--visible] | stop | status");
   }
   let platform = "ios";
   for (let i = 1; i < args.length; i++) {
@@ -27912,13 +28116,14 @@ var init_registry = __esm({
         inputSchema: { type: "object", properties: { json: { type: "boolean", description: "Return raw JSON instead of formatted text." } } },
         argDecode: (p) => p.json ? ["--json"] : []
       } }),
-      m("sim", "Simulator/emulator lifecycle", { usage: "start|stop|status [--platform ios|android] [--device <name>]", mcp: {
-        description: "Manage iOS simulator or Android emulator lifecycle. Start boots the simulator/emulator and launches the browse runner. Stop kills the runner and optionally shuts down the device. Status shows the current runner health.",
-        inputSchema: { type: "object", properties: { action: { type: "string", description: "Lifecycle action.", enum: ["start", "stop", "status"] }, platform: { type: "string", description: "Target platform.", enum: ["ios", "android"] }, device: { type: "string", description: "Device name, UDID, or serial." } }, required: ["action"] },
+      m("sim", "Simulator/emulator lifecycle", { usage: "start|stop|status [--platform ios|android] [--device <name>] [--app <id-or-path>]", mcp: {
+        description: "Manage iOS simulator or Android emulator lifecycle. Start boots the simulator/emulator, optionally installs an app from a file path (.app/.ipa/.apk), and launches the browse runner. Stop kills the runner and optionally shuts down the device. Status shows the current runner health.",
+        inputSchema: { type: "object", properties: { action: { type: "string", description: "Lifecycle action.", enum: ["start", "stop", "status"] }, platform: { type: "string", description: "Target platform.", enum: ["ios", "android"] }, device: { type: "string", description: "Device name, UDID, or serial." }, app: { type: "string", description: "Bundle ID, package name, or path to .app/.ipa/.apk file to install and test." } }, required: ["action"] },
         argDecode: (p) => {
           const args = [String(p.action)];
           if (p.platform) args.push("--platform", String(p.platform));
           if (p.device) args.push("--device", String(p.device));
+          if (p.app) args.push("--app", String(p.app));
           return args;
         }
       } })
@@ -28470,9 +28675,9 @@ var manager_exports2 = {};
 __export(manager_exports2, {
   AndroidAppManager: () => AndroidAppManager
 });
-function normalizeNode(raw, path24 = []) {
+function normalizeNode(raw, path25 = []) {
   return {
-    path: path24,
+    path: path25,
     role: androidRole(raw.className),
     label: raw.text ?? raw.hint ?? "",
     value: raw.editable ? raw.text ?? "" : void 0,
@@ -28487,7 +28692,7 @@ function normalizeNode(raw, path24 = []) {
     selected: raw.selected,
     editable: raw.editable,
     actions: deriveActions(raw),
-    children: raw.children.map((child, i) => normalizeNode(child, [...path24, i]))
+    children: raw.children.map((child, i) => normalizeNode(child, [...path25, i]))
   };
 }
 function androidRole(className) {
@@ -28603,15 +28808,15 @@ var init_manager2 = __esm({
       }
       /** Tap (click) an element by ref */
       async tap(ref) {
-        const { path: path24, label } = this.resolveRef(ref);
-        const result = await this.bridge.action(path24, "click");
+        const { path: path25, label } = this.resolveRef(ref);
+        const result = await this.bridge.action(path25, "click");
         if (!result.success) throw new Error(result.error ?? "Tap failed");
         return `Tapped ${ref}${label ? ` "${label}"` : ""}`;
       }
       /** Fill a text field by ref */
       async fill(ref, value) {
-        const { path: path24 } = this.resolveRef(ref);
-        const result = await this.bridge.setValue(path24, value);
+        const { path: path25 } = this.resolveRef(ref);
+        const result = await this.bridge.setValue(path25, value);
         if (!result.success) throw new Error(result.error ?? "Fill failed");
         return `Filled ${ref} with "${value}"`;
       }
@@ -28632,8 +28837,8 @@ var init_manager2 = __esm({
         const actionName = actionMap[direction.toLowerCase()];
         if (!actionName) throw new Error(`Invalid swipe direction: ${direction}. Use up/down/left/right.`);
         if (ref) {
-          const { path: path24, label } = this.resolveRef(ref);
-          const result2 = await this.bridge.action(path24, actionName);
+          const { path: path25, label } = this.resolveRef(ref);
+          const result2 = await this.bridge.action(path25, actionName);
           if (!result2.success) return this.swipeBoundaryMessage(direction, result2.error);
           return `Swiped ${direction} on ${ref}${label ? ` "${label}"` : ""}`;
         }
@@ -28799,16 +29004,16 @@ var init_manager3 = __esm({
       /** Tap (press) an element by ref. */
       async tap(ref) {
         this.requireBridge();
-        const { path: path24, label } = this.resolveRef(ref);
-        const result = await this.bridge.action(path24, "AXPress");
+        const { path: path25, label } = this.resolveRef(ref);
+        const result = await this.bridge.action(path25, "AXPress");
         if (!result.success) throw new Error(result.error || "Tap failed");
         return `Tapped ${ref}${label ? ` "${label}"` : ""}`;
       }
       /** Fill a text field by ref. */
       async fill(ref, value) {
         this.requireBridge();
-        const { path: path24 } = this.resolveRef(ref);
-        const result = await this.bridge.setValue(path24, value);
+        const { path: path25 } = this.resolveRef(ref);
+        const result = await this.bridge.setValue(path25, value);
         if (!result.success) throw new Error(result.error || "Fill failed");
         return `Filled ${ref} with "${value}"`;
       }
@@ -28824,8 +29029,8 @@ var init_manager3 = __esm({
         this.requireBridge();
         const actionName = `swipe${direction.charAt(0).toUpperCase()}${direction.slice(1).toLowerCase()}`;
         if (ref) {
-          const { path: path24, label } = this.resolveRef(ref);
-          const result2 = await this.bridge.action(path24, actionName);
+          const { path: path25, label } = this.resolveRef(ref);
+          const result2 = await this.bridge.action(path25, actionName);
           if (!result2.success) throw new Error(result2.error || `Swipe ${direction} failed`);
           return `Swiped ${direction} on ${ref}${label ? ` "${label}"` : ""}`;
         }
@@ -28974,15 +29179,15 @@ var init_manager4 = __esm({
       }
       /** Tap (press) an element by ref */
       async tap(ref) {
-        const { path: path24, label } = this.resolveRef(ref);
-        const result = await this.bridge.action(path24, "AXPress");
+        const { path: path25, label } = this.resolveRef(ref);
+        const result = await this.bridge.action(path25, "AXPress");
         if (!result.success) throw new Error(result.error || "Tap failed");
         return `Tapped ${ref}${label ? ` "${label}"` : ""}`;
       }
       /** Fill a text field by ref */
       async fill(ref, value) {
-        const { path: path24 } = this.resolveRef(ref);
-        const result = await this.bridge.setValue(path24, value);
+        const { path: path25 } = this.resolveRef(ref);
+        const result = await this.bridge.setValue(path25, value);
         if (!result.success) throw new Error(result.error || "Fill failed");
         return `Filled ${ref} with "${value}"`;
       }
@@ -29003,8 +29208,8 @@ var init_manager4 = __esm({
         const actionName = actionMap[direction.toLowerCase()];
         if (!actionName) throw new Error(`Invalid swipe direction: ${direction}. Use up/down/left/right.`);
         if (ref) {
-          const { path: path24, label } = this.resolveRef(ref);
-          const result2 = await this.bridge.action(path24, actionName);
+          const { path: path25, label } = this.resolveRef(ref);
+          const result2 = await this.bridge.action(path25, actionName);
           if (!result2.success) throw new Error(result2.error || `Swipe ${direction} failed`);
           return `Swiped ${direction} on ${ref}${label ? ` "${label}"` : ""}`;
         }
@@ -29128,10 +29333,10 @@ function createAppTargetFactory(appName) {
       const { ensureMacOSBridge: ensureMacOSBridge2, createMacOSBridge: createMacOSBridge2 } = await Promise.resolve().then(() => (init_bridge3(), bridge_exports3));
       const { AppManager: AppManager2 } = await Promise.resolve().then(() => (init_manager4(), manager_exports4));
       const bridgePath = await ensureMacOSBridge2();
-      const { execSync: execSync7 } = await import("child_process");
+      const { execSync: execSync8 } = await import("child_process");
       let pid;
       try {
-        const output = execSync7(`pgrep -xo "${appName}"`, { encoding: "utf-8" }).trim();
+        const output = execSync8(`pgrep -xo "${appName}"`, { encoding: "utf-8" }).trim();
         pid = parseInt(output, 10);
         if (isNaN(pid)) throw new Error(`App '${appName}' is not running`);
       } catch (err) {
@@ -29183,7 +29388,7 @@ __export(resolver_exports, {
 });
 function findLightpanda() {
   try {
-    const result = (0, import_child_process10.execSync)("which lightpanda", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const result = (0, import_child_process11.execSync)("which lightpanda", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     if (result) return result;
   } catch {
   }
@@ -29207,13 +29412,13 @@ async function getRuntime(name) {
   }
   return loader();
 }
-var import_os, import_fs, import_child_process10, import_path, net2, registry2, AVAILABLE_RUNTIMES;
+var import_os, import_fs, import_child_process11, import_path, net2, registry2, AVAILABLE_RUNTIMES;
 var init_resolver = __esm({
   "src/engine/resolver.ts"() {
     "use strict";
     import_os = require("os");
     import_fs = require("fs");
-    import_child_process10 = require("child_process");
+    import_child_process11 = require("child_process");
     import_path = require("path");
     net2 = __toESM(require("net"), 1);
     registry2 = {
@@ -29238,16 +29443,16 @@ var init_resolver = __esm({
             "Lightpanda not found. Install: https://lightpanda.io/docs/open-source/installation"
           );
         }
-        const port = await new Promise((resolve9, reject) => {
+        const port = await new Promise((resolve10, reject) => {
           const srv = net2.createServer();
           srv.listen(0, "127.0.0.1", () => {
             const addr = srv.address();
             const p = typeof addr === "object" && addr ? addr.port : 0;
-            srv.close(() => resolve9(p));
+            srv.close(() => resolve10(p));
           });
           srv.on("error", reject);
         });
-        const child = (0, import_child_process10.spawn)(
+        const child = (0, import_child_process11.spawn)(
           binaryPath,
           ["serve", "--host", "127.0.0.1", "--port", String(port), "--timeout", "604800"],
           { stdio: ["ignore", "pipe", "pipe"] }
@@ -29603,7 +29808,7 @@ var init_domain_filter = __esm({
 });
 
 // src/session/manager.ts
-var fs26, path21, SessionManager;
+var fs27, path22, SessionManager;
 var init_manager5 = __esm({
   "src/session/manager.ts"() {
     "use strict";
@@ -29612,8 +29817,8 @@ var init_manager5 = __esm({
     init_sanitize();
     init_persist();
     init_encryption();
-    fs26 = __toESM(require("fs"), 1);
-    path21 = __toESM(require("path"), 1);
+    fs27 = __toESM(require("fs"), 1);
+    path22 = __toESM(require("path"), 1);
     SessionManager = class {
       sessions = /* @__PURE__ */ new Map();
       /** Factory-created target accessors for setup operations that need target-specific methods */
@@ -29694,8 +29899,8 @@ var init_manager5 = __esm({
           }
           return session;
         }
-        const outputDir = path21.join(this.localDir, "sessions", sanitizeName(sessionId));
-        fs26.mkdirSync(outputDir, { recursive: true });
+        const outputDir = path22.join(this.localDir, "sessions", sanitizeName(sessionId));
+        fs27.mkdirSync(outputDir, { recursive: true });
         const buffers = new SessionBuffers();
         const effectiveFactory = this.appFactories.get(sessionId) ?? this.factory;
         const ct = await effectiveFactory.create(buffers, this.reuseContext && this.sessions.size === 0);
@@ -29892,7 +30097,7 @@ function flushSessionBuffers(session, final) {
     const lines = newEntries.map(
       (e) => `[${new Date(e.timestamp).toISOString()}] [${e.level}] ${e.text}`
     ).join("\n") + "\n";
-    fs27.appendFileSync(consolePath, lines);
+    fs28.appendFileSync(consolePath, lines);
     buffers.lastConsoleFlushed = buffers.consoleTotalAdded;
   }
   let newNetworkCount = buffers.networkTotalAdded - buffers.lastNetworkFlushed;
@@ -29917,7 +30122,7 @@ function flushSessionBuffers(session, final) {
       const lines = prefix.map(
         (e) => `[${new Date(e.timestamp).toISOString()}] ${e.method} ${e.url} \u2192 ${e.status || "pending"} (${e.duration || "?"}ms, ${e.size || "?"}B)`
       ).join("\n") + "\n";
-      fs27.appendFileSync(networkPath, lines);
+      fs28.appendFileSync(networkPath, lines);
       buffers.lastNetworkFlushed += prefixLen;
     }
   }
@@ -29929,11 +30134,11 @@ function trySessionBt(session) {
   return null;
 }
 function isPortFree2(port) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const srv = net3.createServer();
-    srv.once("error", () => resolve9(false));
+    srv.once("error", () => resolve10(false));
     srv.once("listening", () => {
-      srv.close(() => resolve9(true));
+      srv.close(() => resolve10(true));
     });
     srv.listen(port, "127.0.0.1");
   });
@@ -30136,9 +30341,9 @@ async function shutdown() {
   await activeRuntime?.close?.().catch(() => {
   });
   try {
-    const currentState = JSON.parse(fs27.readFileSync(STATE_FILE, "utf-8"));
+    const currentState = JSON.parse(fs28.readFileSync(STATE_FILE, "utf-8"));
     if (currentState.pid === process.pid || currentState.token === AUTH_TOKEN) {
-      fs27.unlinkSync(STATE_FILE);
+      fs28.unlinkSync(STATE_FILE);
     }
   } catch {
   }
@@ -30156,14 +30361,14 @@ async function start() {
     const { SessionBuffers: SessionBuffers2 } = await Promise.resolve().then(() => (init_buffers(), buffers_exports));
     const { createPersistentBrowserTarget: createPersistentBrowserTarget2 } = await Promise.resolve().then(() => (init_target_factory(), target_factory_exports));
     const profileDir = getProfileDir2(LOCAL_DIR7, profileName);
-    fs27.mkdirSync(profileDir, { recursive: true });
+    fs28.mkdirSync(profileDir, { recursive: true });
     const profileTarget = await createPersistentBrowserTarget2(profileDir, () => {
       if (isShuttingDown) return;
       console.error("[browse] Chromium disconnected (profile mode). Shutting down.");
       shutdown();
     });
-    const outputDir = path22.join(LOCAL_DIR7, "sessions", profileName);
-    fs27.mkdirSync(outputDir, { recursive: true });
+    const outputDir = path23.join(LOCAL_DIR7, "sessions", profileName);
+    fs28.mkdirSync(outputDir, { recursive: true });
     profileSession = {
       id: profileName,
       manager: profileTarget.target,
@@ -30305,7 +30510,7 @@ async function start() {
           const context = sessionBt_?.getContext();
           if (context) {
             try {
-              const stateData = JSON.parse(fs27.readFileSync(stateFilePath3, "utf-8"));
+              const stateData = JSON.parse(fs28.readFileSync(stateFilePath3, "utf-8"));
               if (stateData.cookies?.length) {
                 await context.addCookies(stateData.cookies);
               }
@@ -30341,7 +30546,7 @@ async function start() {
     port,
     token: AUTH_TOKEN,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    serverPath: path22.resolve(path22.dirname((0, import_url7.fileURLToPath)(__import_meta_url)), "server.ts")
+    serverPath: path23.resolve(path23.dirname((0, import_url7.fileURLToPath)(__import_meta_url)), "server.ts")
   };
   if (profileName) {
     state.profile = profileName;
@@ -30349,12 +30554,12 @@ async function start() {
   if (DEBUG_PORT > 0) {
     state.debugPort = DEBUG_PORT;
   }
-  fs27.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), { mode: 384 });
+  fs28.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), { mode: 384 });
   console.log(`[browse] Server running on http://127.0.0.1:${port} (PID: ${process.pid})`);
   console.log(`[browse] State file: ${STATE_FILE}`);
   console.log(`[browse] Idle timeout: ${IDLE_TIMEOUT_MS / 1e3}s`);
 }
-var fs27, path22, crypto3, http, import_url7, net3, AUTH_TOKEN, DEBUG_PORT, BROWSE_PORT, BROWSE_INSTANCE, INSTANCE_SUFFIX, LOCAL_DIR7, STATE_FILE, IDLE_TIMEOUT_MS, sessionManager, browser, profileSession, activeRuntime, isShuttingDown, isRemoteBrowser, policyChecker, BOUNDARY_NONCE, rewriteError2, flushInterval, sessionCleanupInterval;
+var fs28, path23, crypto3, http, import_url7, net3, AUTH_TOKEN, DEBUG_PORT, BROWSE_PORT, BROWSE_INSTANCE, INSTANCE_SUFFIX, LOCAL_DIR7, STATE_FILE, IDLE_TIMEOUT_MS, sessionManager, browser, profileSession, activeRuntime, isShuttingDown, isRemoteBrowser, policyChecker, BOUNDARY_NONCE, rewriteError2, flushInterval, sessionCleanupInterval;
 var init_server2 = __esm({
   "src/server.ts"() {
     "use strict";
@@ -30364,8 +30569,8 @@ var init_server2 = __esm({
     init_constants();
     init_action_context();
     init_executor();
-    fs27 = __toESM(require("fs"), 1);
-    path22 = __toESM(require("path"), 1);
+    fs28 = __toESM(require("fs"), 1);
+    path23 = __toESM(require("path"), 1);
     crypto3 = __toESM(require("crypto"), 1);
     http = __toESM(require("http"), 1);
     import_url7 = require("url");
@@ -30427,9 +30632,9 @@ __export(cli_exports, {
   resolveServerScript: () => resolveServerScript
 });
 module.exports = __toCommonJS(cli_exports);
-var fs28 = __toESM(require("fs"), 1);
-var path23 = __toESM(require("path"), 1);
-var import_child_process11 = require("child_process");
+var fs29 = __toESM(require("fs"), 1);
+var path24 = __toESM(require("path"), 1);
+var import_child_process12 = require("child_process");
 var import_url8 = require("url");
 init_constants();
 init_config();
@@ -30463,50 +30668,50 @@ var INSTANCE_SUFFIX2 = BROWSE_PORT2 ? `-${BROWSE_PORT2}` : BROWSE_INSTANCE2 ? `-
 function resolveLocalDir() {
   if (process.env.BROWSE_LOCAL_DIR) {
     try {
-      fs28.mkdirSync(process.env.BROWSE_LOCAL_DIR, { recursive: true });
+      fs29.mkdirSync(process.env.BROWSE_LOCAL_DIR, { recursive: true });
     } catch {
     }
     return process.env.BROWSE_LOCAL_DIR;
   }
   let dir = process.cwd();
   for (let i = 0; i < 20; i++) {
-    if (fs28.existsSync(path23.join(dir, ".git")) || fs28.existsSync(path23.join(dir, ".claude"))) {
-      const browseDir = path23.join(dir, ".browse");
+    if (fs29.existsSync(path24.join(dir, ".git")) || fs29.existsSync(path24.join(dir, ".claude"))) {
+      const browseDir = path24.join(dir, ".browse");
       try {
-        fs28.mkdirSync(browseDir, { recursive: true });
-        const gi = path23.join(browseDir, ".gitignore");
-        if (!fs28.existsSync(gi)) {
-          fs28.writeFileSync(gi, "*\n");
+        fs29.mkdirSync(browseDir, { recursive: true });
+        const gi = path24.join(browseDir, ".gitignore");
+        if (!fs29.existsSync(gi)) {
+          fs29.writeFileSync(gi, "*\n");
         }
       } catch {
       }
       return browseDir;
     }
-    const parent = path23.dirname(dir);
+    const parent = path24.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return "/tmp";
 }
 var LOCAL_DIR8 = resolveLocalDir();
-var STATE_FILE2 = process.env.BROWSE_STATE_FILE || path23.join(LOCAL_DIR8, `browse-server${INSTANCE_SUFFIX2}.json`);
+var STATE_FILE2 = process.env.BROWSE_STATE_FILE || path24.join(LOCAL_DIR8, `browse-server${INSTANCE_SUFFIX2}.json`);
 var MAX_START_WAIT = parseInt(process.env.BROWSE_START_TIMEOUT || "0", 10) || 8e3;
 var LOCK_FILE = STATE_FILE2 + ".lock";
 var LOCK_STALE_MS = DEFAULTS.LOCK_STALE_THRESHOLD_MS;
 var __filename_cli = (0, import_url8.fileURLToPath)(__import_meta_url);
-var __dirname_cli = path23.dirname(__filename_cli);
+var __dirname_cli = path24.dirname(__filename_cli);
 function resolveServerScript(env = process.env, metaDir = __dirname_cli) {
   if (env.BROWSE_SERVER_SCRIPT) {
     return env.BROWSE_SERVER_SCRIPT;
   }
   if (metaDir.startsWith("/")) {
-    const direct = path23.resolve(metaDir, "server.ts");
-    if (fs28.existsSync(direct)) {
+    const direct = path24.resolve(metaDir, "server.ts");
+    if (fs29.existsSync(direct)) {
       return direct;
     }
   }
   const selfPath = (0, import_url8.fileURLToPath)(__import_meta_url);
-  if (fs28.existsSync(selfPath)) {
+  if (fs29.existsSync(selfPath)) {
     return "__self__";
   }
   throw new Error(
@@ -30516,7 +30721,7 @@ function resolveServerScript(env = process.env, metaDir = __dirname_cli) {
 var SERVER_SCRIPT = resolveServerScript();
 function readState3() {
   try {
-    const data = fs28.readFileSync(STATE_FILE2, "utf-8");
+    const data = fs29.readFileSync(STATE_FILE2, "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
@@ -30532,7 +30737,7 @@ function isProcessAlive(pid) {
 }
 async function listInstances() {
   try {
-    const files = fs28.readdirSync(LOCAL_DIR8).filter(
+    const files = fs29.readdirSync(LOCAL_DIR8).filter(
       (f) => f.startsWith("browse-server") && f.endsWith(".json") && !f.endsWith(".lock")
     );
     if (files.length === 0) {
@@ -30542,7 +30747,7 @@ async function listInstances() {
     let found = false;
     for (const file of files) {
       try {
-        const data = JSON.parse(fs28.readFileSync(path23.join(LOCAL_DIR8, file), "utf-8"));
+        const data = JSON.parse(fs29.readFileSync(path24.join(LOCAL_DIR8, file), "utf-8"));
         if (!data.pid || !data.port) continue;
         const alive = isProcessAlive(data.pid);
         let status3 = "dead";
@@ -30565,7 +30770,7 @@ async function listInstances() {
         found = true;
         if (!alive) {
           try {
-            fs28.unlinkSync(path23.join(LOCAL_DIR8, file));
+            fs29.unlinkSync(path24.join(LOCAL_DIR8, file));
           } catch {
           }
         }
@@ -30579,8 +30784,8 @@ async function listInstances() {
 }
 function isBrowseProcess(pid) {
   try {
-    const { execSync: execSync7 } = require("child_process");
-    const cmd = execSync7(`ps -p ${pid} -o command=`, { encoding: "utf-8" }).trim();
+    const { execSync: execSync8 } = require("child_process");
+    const cmd = execSync8(`ps -p ${pid} -o command=`, { encoding: "utf-8" }).trim();
     return cmd.includes("browse") || cmd.includes("__BROWSE_SERVER_MODE");
   } catch {
     return false;
@@ -30588,15 +30793,15 @@ function isBrowseProcess(pid) {
 }
 function acquireLock() {
   try {
-    fs28.writeFileSync(LOCK_FILE, String(process.pid), { flag: "wx" });
+    fs29.writeFileSync(LOCK_FILE, String(process.pid), { flag: "wx" });
     return true;
   } catch (err) {
     if (err.code === "EEXIST") {
       try {
-        const stat = fs28.statSync(LOCK_FILE);
+        const stat = fs29.statSync(LOCK_FILE);
         if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
           try {
-            fs28.unlinkSync(LOCK_FILE);
+            fs29.unlinkSync(LOCK_FILE);
           } catch {
           }
           return acquireLock();
@@ -30610,7 +30815,7 @@ function acquireLock() {
 }
 function releaseLock() {
   try {
-    fs28.unlinkSync(LOCK_FILE);
+    fs29.unlinkSync(LOCK_FILE);
   } catch {
   }
 }
@@ -30627,7 +30832,7 @@ async function startServer() {
       }
       await sleep3(100);
     }
-    if (!fs28.existsSync(LOCK_FILE) || fs28.readFileSync(LOCK_FILE, "utf-8").trim() !== String(process.pid)) {
+    if (!fs29.existsSync(LOCK_FILE) || fs29.readFileSync(LOCK_FILE, "utf-8").trim() !== String(process.pid)) {
       const state = readState3();
       if (state && isProcessAlive(state.pid)) return state;
       throw new Error("Server failed to start (another process is starting it)");
@@ -30637,7 +30842,7 @@ async function startServer() {
     try {
       const oldState = readState3();
       if (oldState && !isProcessAlive(oldState.pid)) {
-        fs28.unlinkSync(STATE_FILE2);
+        fs29.unlinkSync(STATE_FILE2);
       }
     } catch {
     }
@@ -30646,7 +30851,7 @@ async function startServer() {
     const spawnCmd = SERVER_SCRIPT === "__self__" ? [nodeExec, selfPath] : [nodeExec, "--import", "tsx", SERVER_SCRIPT];
     const startTimeout = cliFlags.runtime === "chrome" ? String(DEFAULTS.CHROME_CDP_TIMEOUT_MS + 5e3) : "";
     const spawnEnv = { ...process.env, __BROWSE_SERVER_MODE: "1", BROWSE_LOCAL_DIR: LOCAL_DIR8, BROWSE_INSTANCE: BROWSE_INSTANCE2, ...cliFlags.headed ? { BROWSE_HEADED: "1" } : {}, ...cliFlags.cdpUrl ? { BROWSE_CDP_URL: cliFlags.cdpUrl } : {}, ...cliFlags.profile ? { BROWSE_PROFILE: cliFlags.profile } : {}, ...cliFlags.runtime ? { BROWSE_RUNTIME: cliFlags.runtime } : {}, ...startTimeout ? { BROWSE_START_TIMEOUT: startTimeout } : {} };
-    const proc = (0, import_child_process11.spawn)(spawnCmd[0], spawnCmd.slice(1), {
+    const proc = (0, import_child_process12.spawn)(spawnCmd[0], spawnCmd.slice(1), {
       stdio: ["ignore", "ignore", "pipe"],
       env: spawnEnv,
       detached: true
@@ -30723,7 +30928,7 @@ async function ensureServer() {
   }
   if (state) {
     try {
-      fs28.unlinkSync(STATE_FILE2);
+      fs29.unlinkSync(STATE_FILE2);
     } catch {
     }
   }
@@ -30733,21 +30938,21 @@ async function ensureServer() {
 }
 function cleanOrphanedServers() {
   try {
-    const files = fs28.readdirSync(LOCAL_DIR8);
+    const files = fs29.readdirSync(LOCAL_DIR8);
     for (const file of files) {
       if (!file.startsWith("browse-server") || !file.endsWith(".json") || file.endsWith(".lock")) continue;
-      const filePath = path23.join(LOCAL_DIR8, file);
+      const filePath = path24.join(LOCAL_DIR8, file);
       if (filePath === STATE_FILE2) continue;
       try {
-        const data = JSON.parse(fs28.readFileSync(filePath, "utf-8"));
+        const data = JSON.parse(fs29.readFileSync(filePath, "utf-8"));
         if (!data.pid) {
-          fs28.unlinkSync(filePath);
+          fs29.unlinkSync(filePath);
           continue;
         }
         const suffixMatch = file.match(/browse-server-(\d+)\.json$/);
         if (suffixMatch && data.port === parseInt(suffixMatch[1], 10) && isProcessAlive(data.pid)) continue;
         if (!isProcessAlive(data.pid)) {
-          fs28.unlinkSync(filePath);
+          fs29.unlinkSync(filePath);
           continue;
         }
         if (isBrowseProcess(data.pid)) {
@@ -30758,7 +30963,7 @@ function cleanOrphanedServers() {
         }
       } catch {
         try {
-          fs28.unlinkSync(filePath);
+          fs29.unlinkSync(filePath);
         } catch {
         }
       }
@@ -30878,7 +31083,7 @@ async function sendCommand(state, command, args, retries = 0, sessionId) {
           await sleep3(300);
         }
         try {
-          fs28.unlinkSync(STATE_FILE2);
+          fs29.unlinkSync(STATE_FILE2);
         } catch {
         }
         if (command === "restart") {
@@ -31239,7 +31444,7 @@ if (process.argv.includes("--mcp")) {
   Promise.resolve().then(() => (init_mcp(), mcp_exports)).then((m2) => m2.startMcpServer(jsonMode));
 } else if (process.env.__BROWSE_SERVER_MODE === "1") {
   Promise.resolve().then(() => init_server2());
-} else if (process.argv[1] && fs28.realpathSync(process.argv[1]) === fs28.realpathSync(__filename_cli)) {
+} else if (process.argv[1] && fs29.realpathSync(process.argv[1]) === fs29.realpathSync(__filename_cli)) {
   main().catch((err) => {
     console.error(`[browse] ${err.message}`);
     process.exit(1);