@ulpi/browse 1.0.6 → 1.1.1

package/dist/browse.cjs

@@ -124,7 +124,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@ulpi/browse",
-      version: "1.0.6",
+      version: "1.1.1",
       repository: {
         type: "git",
         url: "https://github.com/ulpi-io/browse"
@@ -149,8 +149,7 @@ var require_package = __commonJS({
         "dist/",
         "skill/",
         "LICENSE",
-        "README.md",
-        "BENCHMARKS.md"
+        "README.md"
       ],
       keywords: [
         "browser",
@@ -174,7 +173,7 @@ const __import_meta_url = require("url").pathToFileURL(__filename).href;' --defi
         test: "vitest run",
         start: "tsx src/server.ts",
         postinstall: "npx playwright install chromium",
-        benchmark: "tsx benchmark.ts"
+        benchmark: "echo 'Benchmarks moved to separate repo'"
       },
       type: "module",
       devDependencies: {
@@ -209,15 +208,31 @@ function installSkill(targetDir) {
   }
   const skillDir = path3.join(dir, ".claude", "skills", "browse");
   fs3.mkdirSync(skillDir, { recursive: true });
-  const skillSource = path3.resolve(path3.dirname((0, import_url.fileURLToPath)(__import_meta_url)), "..", "skill", "SKILL.md");
-  const skillDest = path3.join(skillDir, "SKILL.md");
-  if (!fs3.existsSync(skillSource)) {
-    console.error(`SKILL.md not found at ${skillSource}`);
+  const skillSourceDir = path3.resolve(path3.dirname((0, import_url.fileURLToPath)(__import_meta_url)), "..", "skill");
+  if (!fs3.existsSync(skillSourceDir)) {
+    console.error(`Skill directory not found at ${skillSourceDir}`);
     console.error("Is @ulpi/browse installed correctly?");
     process.exit(1);
   }
-  fs3.copyFileSync(skillSource, skillDest);
-  console.log(`Skill installed: ${path3.relative(dir, skillDest)}`);
+  const mdFiles = fs3.readdirSync(skillSourceDir).filter((f) => f.endsWith(".md"));
+  if (mdFiles.length === 0) {
+    console.error(`No .md files found in ${skillSourceDir}`);
+    process.exit(1);
+  }
+  for (const file of mdFiles) {
+    fs3.copyFileSync(path3.join(skillSourceDir, file), path3.join(skillDir, file));
+    console.log(`Skill installed: ${path3.relative(dir, path3.join(skillDir, file))}`);
+  }
+  const refsSourceDir = path3.join(skillSourceDir, "references");
+  if (fs3.existsSync(refsSourceDir)) {
+    const refsDestDir = path3.join(skillDir, "references");
+    fs3.mkdirSync(refsDestDir, { recursive: true });
+    const refFiles = fs3.readdirSync(refsSourceDir).filter((f) => f.endsWith(".md"));
+    for (const file of refFiles) {
+      fs3.copyFileSync(path3.join(refsSourceDir, file), path3.join(refsDestDir, file));
+      console.log(`Skill installed: ${path3.relative(dir, path3.join(refsDestDir, file))}`);
+    }
+  }
   const settingsPath = path3.join(dir, ".claude", "settings.json");
   let settings = {};
   if (fs3.existsSync(settingsPath)) {
@@ -718,6 +733,10 @@ var init_browser_manager = __esm({
       ownsBrowser = false;
       // Whether this instance uses a persistent browser context (profile mode)
       isPersistent = false;
+      // ─── Handoff state ──────────────────────────────────────
+      isHeaded = false;
+      consecutiveFailures = 0;
+      onCrashCallback;
       constructor(buffers) {
         this.buffers = buffers || new SessionBuffers();
       }
@@ -737,6 +756,7 @@ var init_browser_manager = __esm({
       async launch(onCrash) {
         this.browser = await import_playwright.chromium.launch({ headless: true });
         this.ownsBrowser = true;
+        this.onCrashCallback = onCrash;
         this.browser.on("disconnected", () => {
           if (onCrash) onCrash();
         });
@@ -775,9 +795,9 @@ var init_browser_manager = __esm({
           });
         } catch (err) {
           if (err.message?.includes("Failed to launch") || err.message?.includes("Target closed")) {
-            const fs16 = await import("fs");
+            const fs17 = await import("fs");
             console.error(`[browse] Profile directory corrupted, recreating: ${profileDir}`);
-            fs16.rmSync(profileDir, { recursive: true, force: true });
+            fs17.rmSync(profileDir, { recursive: true, force: true });
             context = await import_playwright.chromium.launchPersistentContext(profileDir, {
               headless: process.env.BROWSE_HEADED !== "1",
               viewport: { width: 1920, height: 1080 }
@@ -844,6 +864,230 @@ var init_browser_manager = __esm({
       getIsPersistent() {
         return this.isPersistent;
       }
+      // ─── React DevTools ──────────────────────────────────
+      reactDevToolsEnabled = false;
+      getReactDevToolsEnabled() {
+        return this.reactDevToolsEnabled;
+      }
+      setReactDevToolsEnabled(enabled) {
+        this.reactDevToolsEnabled = enabled;
+      }
+      getIsHeaded() {
+        return this.isHeaded;
+      }
+      // ─── Failure tracking (auto-suggest handoff) ────────────
+      incrementFailures() {
+        this.consecutiveFailures++;
+      }
+      resetFailures() {
+        this.consecutiveFailures = 0;
+      }
+      getFailureHint() {
+        if (this.consecutiveFailures >= 3 && !this.isHeaded) {
+          return `HINT: ${this.consecutiveFailures} consecutive failures. Consider using 'handoff' to let the user help.`;
+        }
+        return null;
+      }
+      // ─── State save/restore (shared by handoff/resume) ──────
+      async saveState() {
+        if (!this.context) throw new Error("Browser not launched");
+        const cookies = await this.context.cookies();
+        const pages = [];
+        for (const [id, page] of this.pages) {
+          const url = page.url();
+          let storage = null;
+          try {
+            storage = await page.evaluate(() => ({
+              localStorage: { ...localStorage },
+              sessionStorage: { ...sessionStorage }
+            }));
+          } catch {
+          }
+          pages.push({
+            url: url === "about:blank" ? "" : url,
+            isActive: id === this.activeTabId,
+            storage
+          });
+        }
+        return { cookies, pages };
+      }
+      async applyContextOptions(context) {
+        if (Object.keys(this.extraHeaders).length > 0) {
+          await context.setExtraHTTPHeaders(this.extraHeaders);
+        }
+        if (this.offline) {
+          await context.setOffline(true);
+        }
+        if (this.initScript) {
+          await context.addInitScript(this.initScript);
+        }
+        for (const r of this.userRoutes) {
+          if (r.action === "block") {
+            await context.route(r.pattern, (route) => route.abort("blockedbyclient"));
+          } else {
+            await context.route(r.pattern, (route) => route.fulfill({ status: r.status || 200, body: r.body || "", contentType: "text/plain" }));
+          }
+        }
+        if (this.domainFilter) {
+          const df = this.domainFilter;
+          await context.route("**/*", (route) => {
+            const url = route.request().url();
+            if (df.isAllowed(url)) {
+              route.fallback();
+            } else {
+              route.abort("blockedbyclient");
+            }
+          });
+        }
+      }
+      async restoreState(state) {
+        if (!this.context) throw new Error("Browser not launched");
+        if (state.cookies.length > 0) {
+          await this.context.addCookies(state.cookies);
+        }
+        await this.applyContextOptions(this.context);
+        let activeId = null;
+        for (const saved of state.pages) {
+          const page = await this.context.newPage();
+          const id = this.nextTabId++;
+          this.pages.set(id, page);
+          this.wirePageEvents(page);
+          if (saved.url) {
+            await page.goto(saved.url, { waitUntil: "domcontentloaded", timeout: 15e3 }).catch(() => {
+            });
+          }
+          if (saved.storage) {
+            try {
+              await page.evaluate((s) => {
+                if (s.localStorage) {
+                  for (const [k, v] of Object.entries(s.localStorage)) localStorage.setItem(k, v);
+                }
+                if (s.sessionStorage) {
+                  for (const [k, v] of Object.entries(s.sessionStorage)) sessionStorage.setItem(k, v);
+                }
+              }, saved.storage);
+            } catch {
+            }
+          }
+          if (saved.isActive) activeId = id;
+        }
+        if (this.pages.size === 0) {
+          await this.newTab();
+        } else if (activeId !== null) {
+          this.activeTabId = activeId;
+        }
+        this.clearRefs();
+      }
+      // ─── Handoff: headless ↔ headed swap ─────────────────────
+      async handoff(message) {
+        if (this.isHeaded) {
+          return `Already in headed mode at ${this.getCurrentUrl()}`;
+        }
+        if (this.isPersistent) {
+          throw new Error("Handoff not supported in profile mode \u2014 the browser is already visible. Use cookie-import or auth login instead.");
+        }
+        if (!this.browser || !this.context) {
+          throw new Error("Browser not launched");
+        }
+        const state = await this.saveState();
+        const currentUrl = this.getCurrentUrl();
+        let newBrowser;
+        try {
+          newBrowser = await import_playwright.chromium.launch({ headless: false, timeout: 15e3 });
+        } catch (err) {
+          return `Cannot open headed browser \u2014 ${err.message}. Headless browser still running.`;
+        }
+        try {
+          const newContext = await newBrowser.newContext({
+            viewport: this.currentDevice?.viewport || { width: 1920, height: 1080 },
+            ...this.customUserAgent ? { userAgent: this.customUserAgent } : {},
+            ...this.currentDevice ? {
+              deviceScaleFactor: this.currentDevice.deviceScaleFactor,
+              isMobile: this.currentDevice.isMobile,
+              hasTouch: this.currentDevice.hasTouch
+            } : {}
+          });
+          const oldContext = this.context;
+          this.browser = newBrowser;
+          this.context = newContext;
+          this.pages.clear();
+          this.nextTabId = 1;
+          this.tabSnapshots.clear();
+          this.activeFramePerTab.clear();
+          const onCrash = this.onCrashCallback;
+          this.browser.on("disconnected", () => {
+            if (onCrash) onCrash();
+          });
+          await this.restoreState(state);
+          this.isHeaded = true;
+          this.ownsBrowser = true;
+          if (oldContext) {
+            await oldContext.close().catch(() => {
+            });
+          }
+          return [
+            `Handoff active \u2014 browser opened in visible mode.`,
+            `Reason: ${message || "manual intervention needed"}`,
+            `URL: ${currentUrl}`,
+            ``,
+            `The user can now interact with the visible browser.`,
+            `When done, run: browse resume`
+          ].join("\n");
+        } catch (err) {
+          await newBrowser.close().catch(() => {
+          });
+          return `Handoff failed during state restore \u2014 ${err.message}. Headless browser still running.`;
+        }
+      }
+      async resume() {
+        if (!this.isHeaded) {
+          throw new Error('Not in handoff mode \u2014 run "handoff" first.');
+        }
+        if (!this.browser || !this.context) {
+          throw new Error("Browser not launched");
+        }
+        const state = await this.saveState();
+        const userUrl = this.getCurrentUrl();
+        let newBrowser;
+        try {
+          newBrowser = await import_playwright.chromium.launch({ headless: true });
+        } catch (err) {
+          return `Cannot launch headless browser \u2014 ${err.message}. Headed browser still running.`;
+        }
+        try {
+          const newContext = await newBrowser.newContext({
+            viewport: this.currentDevice?.viewport || { width: 1920, height: 1080 },
+            ...this.customUserAgent ? { userAgent: this.customUserAgent } : {},
+            ...this.currentDevice ? {
+              deviceScaleFactor: this.currentDevice.deviceScaleFactor,
+              isMobile: this.currentDevice.isMobile,
+              hasTouch: this.currentDevice.hasTouch
+            } : {}
+          });
+          const oldBrowser = this.browser;
+          this.browser = newBrowser;
+          this.context = newContext;
+          this.pages.clear();
+          this.nextTabId = 1;
+          this.tabSnapshots.clear();
+          this.activeFramePerTab.clear();
+          const onCrash = this.onCrashCallback;
+          this.browser.on("disconnected", () => {
+            if (onCrash) onCrash();
+          });
+          await this.restoreState(state);
+          this.isHeaded = false;
+          this.consecutiveFailures = 0;
+          oldBrowser.removeAllListeners("disconnected");
+          oldBrowser.close().catch(() => {
+          });
+          return userUrl;
+        } catch (err) {
+          await newBrowser.close().catch(() => {
+          });
+          return `Resume failed during state restore \u2014 ${err.message}. Headed browser still running.`;
+        }
+      }
       // ─── Tab Management ────────────────────────────────────────
       async newTab(url) {
         if (!this.context) throw new Error("Browser not launched");
@@ -1308,8 +1552,8 @@ var init_browser_manager = __esm({
       // ─── Video Recording ──────────────────────────────────────
       async startVideoRecording(dir) {
         if (this.videoRecording) throw new Error("Video recording already active");
-        const fs16 = await import("fs");
-        fs16.mkdirSync(dir, { recursive: true });
+        const fs17 = await import("fs");
+        fs17.mkdirSync(dir, { recursive: true });
         this.videoRecording = { dir, startedAt: Date.now() };
         const viewport = this.currentDevice?.viewport || { width: 1920, height: 1080 };
         await this.recreateContext({
@@ -2505,6 +2749,21 @@ async function handleWriteCommand(command, args, bm, domainFilter) {
         await page.waitForLoadState(state2, { timeout: timeout2 });
         return `Load state reached: ${state2}`;
       }
+      if (selector === "--download") {
+        const pathOrTimeout = args[1];
+        const timeout2 = args[2] ? parseInt(args[2], 10) : pathOrTimeout && /^\d+$/.test(pathOrTimeout) ? parseInt(pathOrTimeout, 10) : 3e4;
+        const savePath = pathOrTimeout && !/^\d+$/.test(pathOrTimeout) ? pathOrTimeout : null;
+        const download = await page.waitForEvent("download", { timeout: timeout2 });
+        const filename = download.suggestedFilename();
+        const failure = await download.failure();
+        if (failure) return `Download failed: ${filename} \u2014 ${failure}`;
+        if (savePath) {
+          await download.saveAs(savePath);
+          return `Downloaded: ${savePath} (${filename})`;
+        }
+        const tmpPath = await download.path();
+        return `Downloaded: ${filename} (saved to ${tmpPath})`;
+      }
       if (/^\d+$/.test(selector)) {
         const ms = parseInt(selector, 10);
         await page.waitForTimeout(ms);
@@ -2961,6 +3220,11 @@ var init_write = __esm({
 });
 
 // src/snapshot.ts
+var snapshot_exports = {};
+__export(snapshot_exports, {
+  handleSnapshot: () => handleSnapshot,
+  parseSnapshotArgs: () => parseSnapshotArgs
+});
 function parseSnapshotArgs(args) {
   const opts = {};
   for (let i = 0; i < args.length; i++) {
@@ -3683,11 +3947,11 @@ var init_lib = __esm({
           }
         }
       },
-      addToPath: function addToPath(path13, added, removed, oldPosInc, options) {
-        var last = path13.lastComponent;
+      addToPath: function addToPath(path14, added, removed, oldPosInc, options) {
+        var last = path14.lastComponent;
         if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
           return {
-            oldPos: path13.oldPos + oldPosInc,
+            oldPos: path14.oldPos + oldPosInc,
             lastComponent: {
               count: last.count + 1,
               added,
@@ -3697,7 +3961,7 @@ var init_lib = __esm({
           };
         } else {
           return {
-            oldPos: path13.oldPos + oldPosInc,
+            oldPos: path14.oldPos + oldPosInc,
             lastComponent: {
               count: 1,
               added,
@@ -4767,6 +5031,385 @@ var init_record_export = __esm({
   }
 });
 
+// src/react-devtools.ts
+var react_devtools_exports = {};
+__export(react_devtools_exports, {
+  ensureHook: () => ensureHook,
+  getContext: () => getContext,
+  getErrors: () => getErrors,
+  getHydration: () => getHydration,
+  getOwners: () => getOwners,
+  getProfiler: () => getProfiler,
+  getProps: () => getProps,
+  getRenders: () => getRenders,
+  getSuspense: () => getSuspense,
+  getTree: () => getTree,
+  injectHook: () => injectHook,
+  isEnabled: () => isEnabled,
+  removeHook: () => removeHook,
+  requireEnabled: () => requireEnabled,
+  requireReact: () => requireReact
+});
+async function ensureHook() {
+  if (fs13.existsSync(HOOK_PATH)) {
+    return fs13.readFileSync(HOOK_PATH, "utf8");
+  }
+  fs13.mkdirSync(CACHE_DIR, { recursive: true });
+  const res = await fetch(HOOK_URL);
+  if (!res.ok) {
+    throw new Error(
+      `Failed to download React DevTools hook (HTTP ${res.status}).
+Manual fallback: npm install -g react-devtools-core, then copy installHook.js to ${HOOK_PATH}`
+    );
+  }
+  const script = await res.text();
+  fs13.writeFileSync(HOOK_PATH, script);
+  return script;
+}
+async function injectHook(bm) {
+  const hookScript = await ensureHook();
+  const context = bm.getContext();
+  if (!context) throw new Error("No browser context available");
+  await context.addInitScript(hookScript);
+  bm.setReactDevToolsEnabled(true);
+}
+function removeHook(bm) {
+  bm.setReactDevToolsEnabled(false);
+}
+function isEnabled(bm) {
+  return bm.getReactDevToolsEnabled();
+}
+function requireEnabled(bm) {
+  if (!isEnabled(bm)) {
+    throw new Error(
+      'React DevTools not enabled. Run "browse react-devtools enable" first.'
+    );
+  }
+}
+async function requireReact(page) {
+  const hasReact = await page.evaluate(() => {
+    const hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+    if (!hook) return false;
+    if (hook.rendererInterfaces && hook.rendererInterfaces.size > 0) return true;
+    if (hook.renderers && hook.renderers.size > 0) return true;
+    return false;
+  });
+  if (!hasReact) {
+    throw new Error("No React detected on this page.");
+  }
+}
+async function getTree(bm, page) {
+  requireEnabled(bm);
+  await requireReact(page);
+  const tree = await page.evaluate(() => {
+    const hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+    function walkFiber(fiber, depth) {
+      const lines2 = [];
+      if (!fiber) return lines2;
+      const name = fiber.type?.displayName || fiber.type?.name || (typeof fiber.type === "string" ? fiber.type : null);
+      if (name) {
+        const indent = "  ".repeat(depth);
+        let extra = "";
+        if (fiber.tag === 13) {
+          const resolved = fiber.memoizedState === null;
+          extra = resolved ? " (resolved)" : " (pending)";
+        }
+        lines2.push(`${indent}${name}${extra}`);
+      }
+      let child = fiber.child;
+      while (child) {
+        lines2.push(...walkFiber(child, name ? depth + 1 : depth));
+        child = child.sibling;
+      }
+      return lines2;
+    }
+    const rendererID = hook.renderers?.keys().next().value ?? 1;
+    const roots = hook.getFiberRoots?.(rendererID);
+    if (!roots || roots.size === 0) return "(no fiber roots found)";
+    const root = roots.values().next().value;
+    const current = root.current;
+    if (!current) return "(no current fiber)";
+    const lines = walkFiber(current, 0);
+    return lines.join("\n") || "(empty tree)";
+  });
+  return tree || "(no component tree available)";
+}
+async function getProps(bm, page, selector) {
+  requireEnabled(bm);
+  await requireReact(page);
+  const resolved = bm.resolveRef(selector);
+  const element = "locator" in resolved ? resolved.locator : page.locator(resolved.selector);
+  const handle = await element.elementHandle();
+  if (!handle) throw new Error(`Element not found: ${selector}`);
+  const result = await page.evaluate((el) => {
+    let fiber = null;
+    for (const key of Object.keys(el)) {
+      if (key.startsWith("__reactFiber$") || key.startsWith("__reactInternalInstance$")) {
+        fiber = el[key];
+        break;
+      }
+    }
+    if (!fiber) return "No React fiber found for this element";
+    while (fiber && typeof fiber.type === "string") {
+      fiber = fiber.return;
+    }
+    if (!fiber) return "No React component found";
+    const name = fiber.type?.displayName || fiber.type?.name || "Anonymous";
+    const props = fiber.memoizedProps || {};
+    const state = fiber.memoizedState;
+    const propEntries = [];
+    for (const [k, v] of Object.entries(props)) {
+      if (k === "children") continue;
+      if (typeof v === "function") {
+        propEntries.push(`${k}: [Function]`);
+        continue;
+      }
+      try {
+        propEntries.push(`${k}: ${JSON.stringify(v)}`);
+      } catch {
+        propEntries.push(`${k}: [Complex]`);
+      }
+    }
+    const stateEntries = [];
+    let hookNode = state;
+    let hookIdx = 0;
+    while (hookNode && typeof hookNode === "object" && "memoizedState" in hookNode) {
+      const val = hookNode.memoizedState;
+      if (val !== void 0 && val !== null) {
+        try {
+          stateEntries.push(`hook[${hookIdx}]: ${JSON.stringify(val)}`);
+        } catch {
+          stateEntries.push(`hook[${hookIdx}]: [Complex]`);
+        }
+      }
+      hookNode = hookNode.next;
+      hookIdx++;
+    }
+    let output = `Component: ${name}
+`;
+    if (propEntries.length) output += `
+Props:
+${propEntries.map((e) => `  ${e}`).join("\n")}
+`;
+    if (stateEntries.length) output += `
+State:
+${stateEntries.map((e) => `  ${e}`).join("\n")}
+`;
+    return output;
+  }, handle);
+  await handle.dispose();
+  return result;
+}
+async function getSuspense(bm, page) {
+  requireEnabled(bm);
+  await requireReact(page);
+  const result = await page.evaluate(() => {
+    const hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+    const rendererID = hook.renderers?.keys().next().value ?? 1;
+    const roots = hook.getFiberRoots?.(rendererID);
+    if (!roots || roots.size === 0) return "No fiber roots found";
+    const root = roots.values().next().value;
+    const boundaries = [];
+    function walk(fiber, path14) {
+      if (!fiber) return;
+      if (fiber.tag === 13) {
+        const resolved = fiber.memoizedState === null;
+        const parent = path14.length > 0 ? path14[path14.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 ? [...path14, name] : path14;
+      let child = fiber.child;
+      while (child) {
+        walk(child, newPath);
+        child = child.sibling;
+      }
+    }
+    walk(root.current, []);
+    return boundaries.length > 0 ? boundaries.join("\n") : "No Suspense boundaries found";
+  });
+  return result;
+}
+async function getErrors(bm, page) {
+  requireEnabled(bm);
+  await requireReact(page);
+  const result = await page.evaluate(() => {
+    const hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+    const rendererID = hook.renderers?.keys().next().value ?? 1;
+    const roots = hook.getFiberRoots?.(rendererID);
+    if (!roots || roots.size === 0) return "No fiber roots found";
+    const root = roots.values().next().value;
+    const errors = [];
+    function walk(fiber) {
+      if (!fiber) return;
+      if (fiber.tag === 1 && fiber.type?.prototype?.componentDidCatch) {
+        const name = fiber.type.displayName || fiber.type.name || "ErrorBoundary";
+        const hasError = fiber.memoizedState?.error;
+        errors.push(`${name} \u2014 ${hasError ? "caught: " + String(hasError) : "no error caught"}`);
+      }
+      let child = fiber.child;
+      while (child) {
+        walk(child);
+        child = child.sibling;
+      }
+    }
+    walk(root.current);
+    return errors.length > 0 ? errors.join("\n") : "No error boundaries found";
+  });
+  return result;
+}
+async function getProfiler(bm, page) {
+  requireEnabled(bm);
+  await requireReact(page);
+  const result = await page.evaluate(() => {
+    const hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+    const rendererID = hook.renderers?.keys().next().value ?? 1;
+    const roots = hook.getFiberRoots?.(rendererID);
+    if (!roots || roots.size === 0) return "No fiber roots found";
+    const root = roots.values().next().value;
+    const timings = [];
+    function walk(fiber) {
+      if (!fiber) return;
+      const name = fiber.type?.displayName || fiber.type?.name;
+      if (name && fiber.actualDuration !== void 0) {
+        timings.push(`${name}: ${fiber.actualDuration.toFixed(1)}ms (self: ${fiber.selfBaseDuration?.toFixed(1) || "?"}ms)`);
+      }
+      let child = fiber.child;
+      while (child) {
+        walk(child);
+        child = child.sibling;
+      }
+    }
+    walk(root.current);
+    return timings.length > 0 ? timings.join("\n") : "No profiling data (requires React profiling build)";
+  });
+  return result;
+}
+async function getHydration(bm, page) {
+  requireEnabled(bm);
+  await requireReact(page);
+  const result = await page.evaluate(() => {
+    const timing = window.__NEXT_BROWSER_REACT_TIMING__;
+    if (timing && timing.length > 0) {
+      const hydrationEntries = timing.filter((t) => t.label.includes("hydrat") || t.label.includes("Hydrat")).map((t) => `${t.label}: ${(t.endTime - t.startTime).toFixed(1)}ms`);
+      if (hydrationEntries.length > 0) return hydrationEntries.join("\n");
+    }
+    const entries = performance.getEntriesByType("measure").filter((e) => e.name.toLowerCase().includes("hydrat"));
+    if (entries.length > 0) {
+      return entries.map((e) => `${e.name}: ${e.duration.toFixed(1)}ms`).join("\n");
+    }
+    return "No hydration timing data. Requires React profiling build or Next.js dev mode.";
+  });
+  return result;
+}
+async function getRenders(bm, page) {
+  requireEnabled(bm);
+  await requireReact(page);
+  const result = await page.evaluate(() => {
+    const hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+    const rendererID = hook.renderers?.keys().next().value ?? 1;
+    const roots = hook.getFiberRoots?.(rendererID);
+    if (!roots || roots.size === 0) return "No fiber roots found";
+    const root = roots.values().next().value;
+    const rendered = [];
+    function walk(fiber) {
+      if (!fiber) return;
+      const name = fiber.type?.displayName || fiber.type?.name;
+      if (name && fiber.alternate && fiber.actualDuration > 0) {
+        rendered.push(`${name} (${fiber.actualDuration.toFixed(1)}ms)`);
+      }
+      let child = fiber.child;
+      while (child) {
+        walk(child);
+        child = child.sibling;
+      }
+    }
+    walk(root.current);
+    return rendered.length > 0 ? `Re-rendered:
+${rendered.join("\n")}` : "No components re-rendered since last commit";
+  });
+  return result;
+}
+async function getOwners(bm, page, selector) {
+  requireEnabled(bm);
+  await requireReact(page);
+  const resolved = bm.resolveRef(selector);
+  const element = "locator" in resolved ? resolved.locator : page.locator(resolved.selector);
+  const handle = await element.elementHandle();
+  if (!handle) throw new Error(`Element not found: ${selector}`);
+  const result = await page.evaluate((el) => {
+    let fiber = null;
+    for (const key of Object.keys(el)) {
+      if (key.startsWith("__reactFiber$") || key.startsWith("__reactInternalInstance$")) {
+        fiber = el[key];
+        break;
+      }
+    }
+    if (!fiber) return "No React fiber found for this element";
+    const chain = [];
+    let current = fiber;
+    while (current) {
+      const name = current.type?.displayName || current.type?.name;
+      if (name && typeof current.type !== "string") {
+        chain.push(name);
+      }
+      current = current.return;
+    }
+    return chain.length > 0 ? chain.join(" \u2192 ") : "No component owners found";
+  }, handle);
+  await handle.dispose();
+  return result;
+}
+async function getContext(bm, page, selector) {
+  requireEnabled(bm);
+  await requireReact(page);
+  const resolved = bm.resolveRef(selector);
+  const element = "locator" in resolved ? resolved.locator : page.locator(resolved.selector);
+  const handle = await element.elementHandle();
+  if (!handle) throw new Error(`Element not found: ${selector}`);
+  const result = await page.evaluate((el) => {
+    let fiber = null;
+    for (const key of Object.keys(el)) {
+      if (key.startsWith("__reactFiber$") || key.startsWith("__reactInternalInstance$")) {
+        fiber = el[key];
+        break;
+      }
+    }
+    if (!fiber) return "No React fiber found for this element";
+    while (fiber && typeof fiber.type === "string") fiber = fiber.return;
+    if (!fiber) return "No React component found";
+    const deps = fiber.dependencies;
+    if (!deps || !deps.firstContext) return "No context consumed by this component";
+    const contexts = [];
+    let ctx = deps.firstContext;
+    while (ctx) {
+      const name = ctx.context?.displayName || ctx.context?._debugLabel || "UnnamedContext";
+      const value = ctx.context?._currentValue;
+      try {
+        contexts.push(`${name}: ${JSON.stringify(value, null, 2)}`);
+      } catch {
+        contexts.push(`${name}: [Complex value]`);
+      }
+      ctx = ctx.next;
+    }
+    return contexts.length > 0 ? contexts.join("\n\n") : "No context consumed";
+  }, handle);
+  await handle.dispose();
+  return result;
+}
+var fs13, path11, os3, CACHE_DIR, HOOK_PATH, HOOK_URL;
+var init_react_devtools = __esm({
+  "src/react-devtools.ts"() {
+    "use strict";
+    fs13 = __toESM(require("fs"), 1);
+    path11 = __toESM(require("path"), 1);
+    os3 = __toESM(require("os"), 1);
+    CACHE_DIR = path11.join(os3.homedir(), ".cache", "browse", "react-devtools");
+    HOOK_PATH = path11.join(CACHE_DIR, "installHook.js");
+    HOOK_URL = "https://unpkg.com/react-devtools-core@latest/dist/installHook.js";
+  }
+});
+
 // src/commands/meta.ts
 async function handleMetaCommand(command, args, bm, shutdown2, sessionManager2, currentSession) {
   switch (command) {
@@ -4849,7 +5492,7 @@ async function handleMetaCommand(command, args, bm, shutdown2, sessionManager2,
           const lines = entries.map(
             (e) => `[${new Date(e.timestamp).toISOString()}] [${e.level}] ${e.text}`
           ).join("\n") + "\n";
-          fs13.appendFileSync(consolePath, lines);
+          fs14.appendFileSync(consolePath, lines);
           buffers.lastConsoleFlushed = buffers.consoleTotalAdded;
         }
         const newNetworkCount = buffers.networkTotalAdded - buffers.lastNetworkFlushed;
@@ -4859,7 +5502,7 @@ async function handleMetaCommand(command, args, bm, shutdown2, sessionManager2,
           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";
-          fs13.appendFileSync(networkPath, lines);
+          fs14.appendFileSync(networkPath, lines);
           buffers.lastNetworkFlushed = buffers.networkTotalAdded;
         }
       }
@@ -4876,22 +5519,22 @@ async function handleMetaCommand(command, args, bm, shutdown2, sessionManager2,
       const statesDir = `${LOCAL_DIR}/states`;
       const statePath = `${statesDir}/${name}.json`;
       if (subcommand === "list") {
-        if (!fs13.existsSync(statesDir)) return "(no saved states)";
-        const files = fs13.readdirSync(statesDir).filter((f) => f.endsWith(".json"));
+        if (!fs14.existsSync(statesDir)) return "(no saved states)";
+        const files = fs14.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 = fs13.statSync(fp);
+          const stat = fs14.statSync(fp);
           lines.push(`  ${file.replace(".json", "")}  ${stat.size}B  ${new Date(stat.mtimeMs).toISOString()}`);
         }
         return lines.join("\n");
       }
       if (subcommand === "show") {
-        if (!fs13.existsSync(statePath)) {
+        if (!fs14.existsSync(statePath)) {
           throw new Error(`State file not found: ${statePath}`);
         }
-        const data = JSON.parse(fs13.readFileSync(statePath, "utf-8"));
+        const data = JSON.parse(fs14.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);
@@ -4916,15 +5559,15 @@ async function handleMetaCommand(command, args, bm, shutdown2, sessionManager2,
         const context = bm.getContext();
         if (!context) throw new Error("No browser context");
         const state = await context.storageState();
-        fs13.mkdirSync(statesDir, { recursive: true });
-        fs13.writeFileSync(statePath, JSON.stringify(state, null, 2), { mode: 384 });
+        fs14.mkdirSync(statesDir, { recursive: true });
+        fs14.writeFileSync(statePath, JSON.stringify(state, null, 2), { mode: 384 });
         return `State saved: ${statePath}`;
       }
       if (subcommand === "load") {
-        if (!fs13.existsSync(statePath)) {
+        if (!fs14.existsSync(statePath)) {
           throw new Error(`State file not found: ${statePath}. Run "browse state save ${name}" first.`);
         }
-        const stateData = JSON.parse(fs13.readFileSync(statePath, "utf-8"));
+        const stateData = JSON.parse(fs14.readFileSync(statePath, "utf-8"));
         const context = bm.getContext();
         if (!context) throw new Error("No browser context");
         const warnings = [];
@@ -5083,9 +5726,9 @@ ${legend.join("\n")}`;
       try {
         for (const vp of viewports) {
           await page.setViewportSize({ width: vp.width, height: vp.height });
-          const path13 = `${prefix}-${vp.name}.png`;
-          await page.screenshot({ path: path13, fullPage: true });
-          results.push(`${vp.name} (${vp.width}x${vp.height}): ${path13}`);
+          const path14 = `${prefix}-${vp.name}.png`;
+          await page.screenshot({ path: path14, fullPage: true });
+          results.push(`${vp.name} (${vp.width}x${vp.height}): ${path14}`);
         }
       } finally {
         if (originalViewport) {
@@ -5229,13 +5872,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 (!fs13.existsSync(baseline)) throw new Error(`Baseline file not found: ${baseline}`);
+      if (!fs14.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 = fs13.readFileSync(baseline);
+      const baselineBuffer = fs14.readFileSync(baseline);
       let currentBuffer;
       let currentPath;
       for (let i = 1; i < diffArgs.length; i++) {
@@ -5249,8 +5892,8 @@ ${legend.join("\n")}`;
         }
       }
       if (currentPath) {
-        if (!fs13.existsSync(currentPath)) throw new Error(`Current screenshot not found: ${currentPath}`);
-        currentBuffer = fs13.readFileSync(currentPath);
+        if (!fs14.existsSync(currentPath)) throw new Error(`Current screenshot not found: ${currentPath}`);
+        currentBuffer = fs14.readFileSync(currentPath);
       } else {
         const page = bm.getPage();
         currentBuffer = await page.screenshot({ fullPage: isFullPageDiff });
@@ -5260,7 +5903,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) {
-        fs13.writeFileSync(diffPath, result.diffImage);
+        fs14.writeFileSync(diffPath, result.diffImage);
       }
       return [
         `Pixels: ${result.totalPixels}`,
@@ -5396,7 +6039,7 @@ ${legend.join("\n")}`;
         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_DIR}/browse-recording.har`);
-        fs13.writeFileSync(harPath, JSON.stringify(har, null, 2));
+        fs14.writeFileSync(harPath, JSON.stringify(har, null, 2));
         const entryCount = har.log.entries.length;
         return `HAR saved: ${harPath} (${entryCount} entries)`;
       }
@@ -5459,6 +6102,20 @@ ${output.trim()}`;
 Manual: npm install -g @ulpi/browse`;
       }
     }
+    // ─── Handoff ────────────────────────────────────────
+    case "handoff": {
+      const message = args.join(" ") || "User takeover requested";
+      return await bm.handoff(message);
+    }
+    case "resume": {
+      const url = await bm.resume();
+      const { handleSnapshot: handleSnapshot2 } = await Promise.resolve().then(() => (init_snapshot(), snapshot_exports));
+      const snapshot = await handleSnapshot2(["-i"], bm);
+      return `Resumed \u2014 back to headless.
+URL: ${url}
+
+${snapshot}`;
+    }
     // ─── Semantic Locator ──────────────────────────────
     case "find": {
       const root = bm.getLocatorRoot();
@@ -5616,7 +6273,7 @@ Manual: npm install -g @ulpi/browse`;
         }
         const filePath = args[2];
         if (filePath) {
-          fs13.writeFileSync(filePath, output);
+          fs14.writeFileSync(filePath, output);
           return `Exported ${steps.length} steps as ${format}: ${filePath}`;
         }
         return output;
@@ -5662,11 +6319,59 @@ Manual: npm install -g @ulpi/browse`;
       }
       throw new Error("Usage: browse profile list | delete <name> | clean [--older-than <days>]");
     }
+    // ─── React DevTools ──────────────────────────────────
+    case "react-devtools": {
+      const sub = args[0];
+      if (!sub) throw new Error(
+        "Usage: browse react-devtools enable|disable|tree|props|suspense|errors|profiler|hydration|renders|owners|context"
+      );
+      const rd = await Promise.resolve().then(() => (init_react_devtools(), react_devtools_exports));
+      switch (sub) {
+        case "enable": {
+          if (rd.isEnabled(bm)) return "React DevTools already enabled.";
+          await rd.injectHook(bm);
+          await bm.getPage().reload();
+          return "React DevTools enabled. Page reloaded.";
+        }
+        case "disable": {
+          rd.removeHook(bm);
+          return "React DevTools disabled. Takes effect on next navigation.";
+        }
+        case "tree":
+          return await rd.getTree(bm, bm.getPage());
+        case "props": {
+          if (!args[1]) throw new Error("Usage: browse react-devtools props <selector|@ref>");
+          return await rd.getProps(bm, bm.getPage(), args[1]);
+        }
+        case "suspense":
+          return await rd.getSuspense(bm, bm.getPage());
+        case "errors":
+          return await rd.getErrors(bm, bm.getPage());
+        case "profiler":
+          return await rd.getProfiler(bm, bm.getPage());
+        case "hydration":
+          return await rd.getHydration(bm, bm.getPage());
+        case "renders":
+          return await rd.getRenders(bm, bm.getPage());
+        case "owners": {
+          if (!args[1]) throw new Error("Usage: browse react-devtools owners <selector|@ref>");
+          return await rd.getOwners(bm, bm.getPage(), args[1]);
+        }
+        case "context": {
+          if (!args[1]) throw new Error("Usage: browse react-devtools context <selector|@ref>");
+          return await rd.getContext(bm, bm.getPage(), args[1]);
+        }
+        default:
+          throw new Error(
+            `Unknown subcommand: ${sub}. Use: enable|disable|tree|props|suspense|errors|profiler|hydration|renders|owners|context`
+          );
+      }
+    }
     default:
       throw new Error(`Unknown meta command: ${command}`);
   }
 }
-var fs13, LOCAL_DIR;
+var fs14, LOCAL_DIR;
 var init_meta = __esm({
   "src/commands/meta.ts"() {
     "use strict";
@@ -5674,7 +6379,7 @@ var init_meta = __esm({
     init_constants();
     init_sanitize();
     init_lib();
-    fs13 = __toESM(require("fs"), 1);
+    fs14 = __toESM(require("fs"), 1);
     LOCAL_DIR = process.env.BROWSE_LOCAL_DIR || "/tmp";
   }
 });
@@ -5732,7 +6437,7 @@ function flushSessionBuffers(session, final) {
     const lines = newEntries.map(
       (e) => `[${new Date(e.timestamp).toISOString()}] [${e.level}] ${e.text}`
     ).join("\n") + "\n";
-    fs14.appendFileSync(consolePath, lines);
+    fs15.appendFileSync(consolePath, lines);
     buffers.lastConsoleFlushed = buffers.consoleTotalAdded;
   }
   let newNetworkCount = buffers.networkTotalAdded - buffers.lastNetworkFlushed;
@@ -5757,7 +6462,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";
-      fs14.appendFileSync(networkPath, lines);
+      fs15.appendFileSync(networkPath, lines);
       buffers.lastNetworkFlushed += prefixLen;
     }
   }
@@ -5886,6 +6591,7 @@ async function handleCommand(body, session, opts) {
         headers: { "Content-Type": "application/json" }
       });
     }
+    session.manager.resetFailures();
     if (session.recording && !RECORDING_SKIP.has(command)) {
       session.recording.push({ command, args, timestamp: Date.now() });
     }
@@ -5910,7 +6616,10 @@ ${result}
       headers: { "Content-Type": "text/plain" }
     });
   } catch (err) {
-    const friendlyError = rewriteError(err.message);
+    session.manager.incrementFailures();
+    let friendlyError = rewriteError(err.message);
+    const hint = session.manager.getFailureHint();
+    if (hint) friendlyError += "\n" + hint;
     if (opts.jsonMode) {
       return new Response(JSON.stringify({ success: false, error: friendlyError, command }), {
         status: 500,
@@ -5944,9 +6653,9 @@ async function shutdown() {
   await activeRuntime?.close?.().catch(() => {
   });
   try {
-    const currentState = JSON.parse(fs14.readFileSync(STATE_FILE, "utf-8"));
+    const currentState = JSON.parse(fs15.readFileSync(STATE_FILE, "utf-8"));
     if (currentState.pid === process.pid || currentState.token === AUTH_TOKEN) {
-      fs14.unlinkSync(STATE_FILE);
+      fs15.unlinkSync(STATE_FILE);
     }
   } catch {
   }
@@ -5963,15 +6672,15 @@ async function start() {
     const { BrowserManager: BrowserManager2, getProfileDir: getProfileDir2 } = await Promise.resolve().then(() => (init_browser_manager(), browser_manager_exports));
     const { SessionBuffers: SessionBuffers2 } = await Promise.resolve().then(() => (init_buffers(), buffers_exports));
     const profileDir = getProfileDir2(LOCAL_DIR2, profileName);
-    fs14.mkdirSync(profileDir, { recursive: true });
+    fs15.mkdirSync(profileDir, { recursive: true });
     const bm = new BrowserManager2();
     await bm.launchPersistent(profileDir, () => {
       if (isShuttingDown) return;
       console.error("[browse] Chromium disconnected (profile mode). Shutting down.");
       shutdown();
     });
-    const outputDir = path11.join(LOCAL_DIR2, "sessions", profileName);
-    fs14.mkdirSync(outputDir, { recursive: true });
+    const outputDir = path12.join(LOCAL_DIR2, "sessions", profileName);
+    fs15.mkdirSync(outputDir, { recursive: true });
     profileSession = {
       id: profileName,
       manager: bm,
@@ -6065,7 +6774,7 @@ async function start() {
           const context = session.manager.getContext();
           if (context) {
             try {
-              const stateData = JSON.parse(fs14.readFileSync(stateFilePath, "utf-8"));
+              const stateData = JSON.parse(fs15.readFileSync(stateFilePath, "utf-8"));
               if (stateData.cookies?.length) {
                 await context.addCookies(stateData.cookies);
               }
@@ -6092,7 +6801,7 @@ async function start() {
     port,
     token: AUTH_TOKEN,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    serverPath: path11.resolve(path11.dirname((0, import_url2.fileURLToPath)(__import_meta_url)), "server.ts")
+    serverPath: path12.resolve(path12.dirname((0, import_url2.fileURLToPath)(__import_meta_url)), "server.ts")
   };
   if (profileName) {
     state.profile = profileName;
@@ -6100,12 +6809,12 @@ async function start() {
   if (DEBUG_PORT > 0) {
     state.debugPort = DEBUG_PORT;
   }
-  fs14.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), { mode: 384 });
+  fs15.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 fs14, path11, crypto3, http, import_url2, net2, AUTH_TOKEN, DEBUG_PORT, BROWSE_PORT, BROWSE_INSTANCE, INSTANCE_SUFFIX, LOCAL_DIR2, STATE_FILE, IDLE_TIMEOUT_MS, sessionManager, browser, profileSession, activeRuntime, isShuttingDown, isRemoteBrowser, policyChecker, READ_COMMANDS, WRITE_COMMANDS, META_COMMANDS, RECORDING_SKIP, PAGE_CONTENT_COMMANDS, BOUNDARY_NONCE, flushInterval, sessionCleanupInterval;
+var fs15, path12, crypto3, http, import_url2, net2, AUTH_TOKEN, DEBUG_PORT, BROWSE_PORT, BROWSE_INSTANCE, INSTANCE_SUFFIX, LOCAL_DIR2, STATE_FILE, IDLE_TIMEOUT_MS, sessionManager, browser, profileSession, activeRuntime, isShuttingDown, isRemoteBrowser, policyChecker, READ_COMMANDS, WRITE_COMMANDS, META_COMMANDS, RECORDING_SKIP, PAGE_CONTENT_COMMANDS, BOUNDARY_NONCE, flushInterval, sessionCleanupInterval;
 var init_server = __esm({
   "src/server.ts"() {
     "use strict";
@@ -6116,8 +6825,8 @@ var init_server = __esm({
     init_meta();
     init_policy();
     init_constants();
-    fs14 = __toESM(require("fs"), 1);
-    path11 = __toESM(require("path"), 1);
+    fs15 = __toESM(require("fs"), 1);
+    path12 = __toESM(require("path"), 1);
     crypto3 = __toESM(require("crypto"), 1);
     http = __toESM(require("http"), 1);
     import_url2 = require("url");
@@ -6231,7 +6940,10 @@ var init_server = __esm({
       "cookie-import",
       "doctor",
       "upgrade",
-      "profile"
+      "handoff",
+      "resume",
+      "profile",
+      "react-devtools"
     ]);
     RECORDING_SKIP = /* @__PURE__ */ new Set([
       "record",
@@ -6299,8 +7011,8 @@ __export(cli_exports, {
   resolveServerScript: () => resolveServerScript
 });
 module.exports = __toCommonJS(cli_exports);
-var fs15 = __toESM(require("fs"), 1);
-var path12 = __toESM(require("path"), 1);
+var fs16 = __toESM(require("fs"), 1);
+var path13 = __toESM(require("path"), 1);
 var import_child_process3 = require("child_process");
 var import_url3 = require("url");
 init_constants();
@@ -6354,50 +7066,50 @@ var INSTANCE_SUFFIX2 = BROWSE_PORT2 ? `-${BROWSE_PORT2}` : BROWSE_INSTANCE2 ? `-
 function resolveLocalDir() {
   if (process.env.BROWSE_LOCAL_DIR) {
     try {
-      fs15.mkdirSync(process.env.BROWSE_LOCAL_DIR, { recursive: true });
+      fs16.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 (fs15.existsSync(path12.join(dir, ".git")) || fs15.existsSync(path12.join(dir, ".claude"))) {
-      const browseDir = path12.join(dir, ".browse");
+    if (fs16.existsSync(path13.join(dir, ".git")) || fs16.existsSync(path13.join(dir, ".claude"))) {
+      const browseDir = path13.join(dir, ".browse");
       try {
-        fs15.mkdirSync(browseDir, { recursive: true });
-        const gi = path12.join(browseDir, ".gitignore");
-        if (!fs15.existsSync(gi)) {
-          fs15.writeFileSync(gi, "*\n");
+        fs16.mkdirSync(browseDir, { recursive: true });
+        const gi = path13.join(browseDir, ".gitignore");
+        if (!fs16.existsSync(gi)) {
+          fs16.writeFileSync(gi, "*\n");
         }
       } catch {
       }
       return browseDir;
     }
-    const parent = path12.dirname(dir);
+    const parent = path13.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return "/tmp";
 }
 var LOCAL_DIR3 = resolveLocalDir();
-var STATE_FILE2 = process.env.BROWSE_STATE_FILE || path12.join(LOCAL_DIR3, `browse-server${INSTANCE_SUFFIX2}.json`);
+var STATE_FILE2 = process.env.BROWSE_STATE_FILE || path13.join(LOCAL_DIR3, `browse-server${INSTANCE_SUFFIX2}.json`);
 var MAX_START_WAIT = 8e3;
 var LOCK_FILE = STATE_FILE2 + ".lock";
 var LOCK_STALE_MS = DEFAULTS.LOCK_STALE_THRESHOLD_MS;
 var __filename_cli = (0, import_url3.fileURLToPath)(__import_meta_url);
-var __dirname_cli = path12.dirname(__filename_cli);
+var __dirname_cli = path13.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 = path12.resolve(metaDir, "server.ts");
-    if (fs15.existsSync(direct)) {
+    const direct = path13.resolve(metaDir, "server.ts");
+    if (fs16.existsSync(direct)) {
       return direct;
     }
   }
   const selfPath = (0, import_url3.fileURLToPath)(__import_meta_url);
-  if (fs15.existsSync(selfPath)) {
+  if (fs16.existsSync(selfPath)) {
     return "__self__";
   }
   throw new Error(
@@ -6407,7 +7119,7 @@ function resolveServerScript(env = process.env, metaDir = __dirname_cli) {
 var SERVER_SCRIPT = resolveServerScript();
 function readState() {
   try {
-    const data = fs15.readFileSync(STATE_FILE2, "utf-8");
+    const data = fs16.readFileSync(STATE_FILE2, "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
@@ -6423,7 +7135,7 @@ function isProcessAlive(pid) {
 }
 async function listInstances() {
   try {
-    const files = fs15.readdirSync(LOCAL_DIR3).filter(
+    const files = fs16.readdirSync(LOCAL_DIR3).filter(
       (f) => f.startsWith("browse-server") && f.endsWith(".json") && !f.endsWith(".lock")
     );
     if (files.length === 0) {
@@ -6433,7 +7145,7 @@ async function listInstances() {
     let found = false;
     for (const file of files) {
       try {
-        const data = JSON.parse(fs15.readFileSync(path12.join(LOCAL_DIR3, file), "utf-8"));
+        const data = JSON.parse(fs16.readFileSync(path13.join(LOCAL_DIR3, file), "utf-8"));
         if (!data.pid || !data.port) continue;
         const alive = isProcessAlive(data.pid);
         let status = "dead";
@@ -6456,7 +7168,7 @@ async function listInstances() {
         found = true;
         if (!alive) {
           try {
-            fs15.unlinkSync(path12.join(LOCAL_DIR3, file));
+            fs16.unlinkSync(path13.join(LOCAL_DIR3, file));
           } catch {
           }
         }
@@ -6479,15 +7191,15 @@ function isBrowseProcess(pid) {
 }
 function acquireLock() {
   try {
-    fs15.writeFileSync(LOCK_FILE, String(process.pid), { flag: "wx" });
+    fs16.writeFileSync(LOCK_FILE, String(process.pid), { flag: "wx" });
     return true;
   } catch (err) {
     if (err.code === "EEXIST") {
       try {
-        const stat = fs15.statSync(LOCK_FILE);
+        const stat = fs16.statSync(LOCK_FILE);
         if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
           try {
-            fs15.unlinkSync(LOCK_FILE);
+            fs16.unlinkSync(LOCK_FILE);
           } catch {
           }
           return acquireLock();
@@ -6501,7 +7213,7 @@ function acquireLock() {
 }
 function releaseLock() {
   try {
-    fs15.unlinkSync(LOCK_FILE);
+    fs16.unlinkSync(LOCK_FILE);
   } catch {
   }
 }
@@ -6518,7 +7230,7 @@ async function startServer() {
       }
       await sleep(100);
     }
-    if (!fs15.existsSync(LOCK_FILE) || fs15.readFileSync(LOCK_FILE, "utf-8").trim() !== String(process.pid)) {
+    if (!fs16.existsSync(LOCK_FILE) || fs16.readFileSync(LOCK_FILE, "utf-8").trim() !== String(process.pid)) {
       const state = readState();
       if (state && isProcessAlive(state.pid)) return state;
       throw new Error("Server failed to start (another process is starting it)");
@@ -6528,7 +7240,7 @@ async function startServer() {
     try {
       const oldState = readState();
       if (oldState && !isProcessAlive(oldState.pid)) {
-        fs15.unlinkSync(STATE_FILE2);
+        fs16.unlinkSync(STATE_FILE2);
       }
     } catch {
     }
@@ -6602,7 +7314,7 @@ async function ensureServer() {
   }
   if (state) {
     try {
-      fs15.unlinkSync(STATE_FILE2);
+      fs16.unlinkSync(STATE_FILE2);
     } catch {
     }
   }
@@ -6612,21 +7324,21 @@ async function ensureServer() {
 }
 function cleanOrphanedServers() {
   try {
-    const files = fs15.readdirSync(LOCAL_DIR3);
+    const files = fs16.readdirSync(LOCAL_DIR3);
     for (const file of files) {
       if (!file.startsWith("browse-server") || !file.endsWith(".json") || file.endsWith(".lock")) continue;
-      const filePath = path12.join(LOCAL_DIR3, file);
+      const filePath = path13.join(LOCAL_DIR3, file);
       if (filePath === STATE_FILE2) continue;
       try {
-        const data = JSON.parse(fs15.readFileSync(filePath, "utf-8"));
+        const data = JSON.parse(fs16.readFileSync(filePath, "utf-8"));
         if (!data.pid) {
-          fs15.unlinkSync(filePath);
+          fs16.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)) {
-          fs15.unlinkSync(filePath);
+          fs16.unlinkSync(filePath);
           continue;
         }
         if (isBrowseProcess(data.pid)) {
@@ -6637,7 +7349,7 @@ function cleanOrphanedServers() {
         }
       } catch {
         try {
-          fs15.unlinkSync(filePath);
+          fs16.unlinkSync(filePath);
         } catch {
         }
       }
@@ -6677,7 +7389,8 @@ var SAFE_TO_RETRY = /* @__PURE__ */ new Set([
   "box",
   "errors",
   "doctor",
-  "upgrade"
+  "upgrade",
+  "react-devtools"
 ]);
 var PAGE_INDEPENDENT = /* @__PURE__ */ new Set(["devices", "status"]);
 async function sendCommand(state, command, args, retries = 0, sessionId) {
@@ -6738,7 +7451,7 @@ async function sendCommand(state, command, args, retries = 0, sessionId) {
           await sleep(300);
         }
         try {
-          fs15.unlinkSync(STATE_FILE2);
+          fs16.unlinkSync(STATE_FILE2);
         } catch {
         }
         if (command === "restart") {
@@ -6942,22 +7655,25 @@ Interaction:    click <sel> | rightclick <sel> | dblclick <sel>
                 check <sel> | uncheck <sel> | drag <src> <tgt>
                 type <text> | press <key> | keydown <key> | keyup <key>
                 keyboard inserttext <text>
-                scroll [sel|up|down] | scrollinto <sel>
+                scroll [sel|up|down] | scrollinto <sel> | scrollintoview <sel>
                 swipe <up|down|left|right> [px]
                 wait <sel|ms|--url|--text|--fn|--load|--network-idle>
                 viewport <WxH> | highlight <sel> | download <sel> [path]
+                upload <sel> <files...>
+                dialog-accept [text] | dialog-dismiss
 Mouse:          mouse move <x> <y> | mouse down [btn] | mouse up [btn]
                 mouse wheel <dy> [dx]
 Settings:       set geo <lat> <lng> | set media <dark|light|no-preference>
 Device:         emulate <device> | emulate reset | devices [filter]
 Inspection:     js <expr> | eval <file> | css <sel> <prop> | attrs <sel>
-                element-state <sel> | box <sel>
+                element-state <sel> | box <sel> | dialog
                 console [--clear] | errors [--clear] | network [--clear]
                 cookies | storage [set <k> <v>] | perf
                 value <sel> | count <sel> | clipboard [write <text>]
 Visual:         screenshot [sel|@ref] [path] [--full] [--clip x,y,w,h]
                 screenshot --annotate | pdf [path] | responsive [prefix]
 Snapshot:       snapshot [-i] [-f] [-V] [-c] [-C] [-d N] [-s sel]
+                snapshot-diff
 Find:           find role|text|label|placeholder|testid|alt|title <query>
                 find first|last <sel> | find nth <n> <sel>
 Compare:        diff <url1> <url2> | screenshot-diff <baseline> [current]
@@ -6973,10 +7689,13 @@ Recording:      har start | har stop [path]
 Tabs:           tabs | tab <id> | newtab [url] | closetab [id]
 Frames:         frame <sel> | frame main
 Sessions:       sessions | session-close <id>
+Profiles:       --profile <name> | profile list|delete|clean
 Auth:           auth save <name> <url> <user> <pass|--password-stdin>
                 auth login <name> | auth list | auth delete <name>
                 cookie-import --list | cookie-import <browser> [--domain <d>] [--profile <p>]
-State:          state save|load|list|show [name]
+State:          state save|load|list|show|clean [name]
+Handoff:        handoff [reason] | resume
+React:          react-devtools enable|disable|tree|props|suspense|errors|profiler
 Debug:          inspect (requires BROWSE_DEBUG_PORT)
 Server:         status | instances | stop | restart | doctor | upgrade
 Setup:          install-skill [path]
@@ -7023,7 +7742,7 @@ Refs:           After 'snapshot', use @e1, @e2... as selectors:
 }
 if (process.env.__BROWSE_SERVER_MODE === "1") {
   Promise.resolve().then(() => init_server());
-} else if (process.argv[1] && fs15.realpathSync(process.argv[1]) === fs15.realpathSync(__filename_cli)) {
+} else if (process.argv[1] && fs16.realpathSync(process.argv[1]) === fs16.realpathSync(__filename_cli)) {
   main().catch((err) => {
     console.error(`[browse] ${err.message}`);
     process.exit(1);