browserclaw 0.12.2 → 0.12.4

package/dist/index.js

@@ -823,6 +823,19 @@ var require_ipaddr = __commonJS({
     })(exports$1);
   }
 });
+function killProcessTree(proc, signal) {
+  if (process.platform !== "win32" && proc.pid !== void 0) {
+    try {
+      process.kill(-proc.pid, signal);
+      return;
+    } catch {
+    }
+  }
+  try {
+    proc.kill(signal);
+  } catch {
+  }
+}
 var CHROMIUM_BUNDLE_IDS = /* @__PURE__ */ new Set([
   "com.google.Chrome",
   "com.google.Chrome.beta",
@@ -1178,17 +1191,30 @@ function resolveBrowserExecutable(opts) {
   if (platform === "win32") return detectDefaultChromiumWindows() ?? findChromeWindows();
   return null;
 }
-async function ensurePortAvailable(port) {
-  await new Promise((resolve2, reject) => {
-    const tester = net.createServer().once("error", (err) => {
-      if (err.code === "EADDRINUSE") reject(new Error(`Port ${String(port)} is already in use`));
-      else reject(err);
-    }).once("listening", () => {
-      tester.close(() => {
-        resolve2();
+async function ensurePortAvailable(port, retries = 2) {
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      await new Promise((resolve2, reject) => {
+        const tester = net.createServer().once("error", (err) => {
+          tester.close(() => {
+            if (err.code === "EADDRINUSE") reject(new Error(`Port ${String(port)} is already in use`));
+            else reject(err);
+          });
+        }).once("listening", () => {
+          tester.close(() => {
+            resolve2();
+          });
+        }).listen(port);
       });
-    }).listen(port);
-  });
+      return;
+    } catch (err) {
+      if (attempt < retries) {
+        await new Promise((r) => setTimeout(r, 100));
+        continue;
+      }
+      throw err;
+    }
+  }
 }
 function safeReadJson(filePath) {
   try {
@@ -1461,7 +1487,7 @@ async function launchChrome(opts = {}) {
   const profileName = opts.profileName ?? DEFAULT_PROFILE_NAME;
   const userDataDir = opts.userDataDir ?? resolveUserDataDir(profileName);
   fs.mkdirSync(userDataDir, { recursive: true });
-  const spawnChrome = () => {
+  const spawnChrome = (spawnOpts) => {
     const args = [
       `--remote-debugging-port=${String(cdpPort)}`,
       "--remote-debugging-address=127.0.0.1",
@@ -1492,33 +1518,29 @@ async function launchChrome(opts = {}) {
     args.push("about:blank");
     return spawn(exe.path, args, {
       stdio: "pipe",
-      env: { ...process.env, HOME: os.homedir() }
+      env: { ...process.env, HOME: os.homedir() },
+      ...spawnOpts
     });
   };
   const startedAt = Date.now();
   const localStatePath = path.join(userDataDir, "Local State");
   const preferencesPath = path.join(userDataDir, "Default", "Preferences");
   if (!fileExists(localStatePath) || !fileExists(preferencesPath)) {
-    const bootstrap = spawnChrome();
+    const useDetached = process.platform !== "win32";
+    const bootstrap = spawnChrome(useDetached ? { detached: true } : void 0);
     const deadline = Date.now() + 1e4;
     while (Date.now() < deadline) {
       if (fileExists(localStatePath) && fileExists(preferencesPath)) break;
       await new Promise((r) => setTimeout(r, 100));
     }
-    try {
-      bootstrap.kill("SIGTERM");
-    } catch {
-    }
+    killProcessTree(bootstrap, "SIGTERM");
     const exitDeadline = Date.now() + 5e3;
     while (Date.now() < exitDeadline) {
       if (bootstrap.exitCode != null) break;
       await new Promise((r) => setTimeout(r, 50));
     }
     if (bootstrap.exitCode == null) {
-      try {
-        bootstrap.kill("SIGKILL");
-      } catch {
-      }
+      killProcessTree(bootstrap, "SIGKILL");
     }
   }
   try {
@@ -1537,9 +1559,11 @@ async function launchChrome(opts = {}) {
   };
   proc.stderr.on("data", onStderr);
   const readyDeadline = Date.now() + 15e3;
+  let pollDelay = 200;
   while (Date.now() < readyDeadline) {
     if (await isChromeCdpReady(cdpUrl, 500)) break;
-    await new Promise((r) => setTimeout(r, 200));
+    await new Promise((r) => setTimeout(r, pollDelay));
+    pollDelay = Math.min(pollDelay + 100, 1e3);
   }
   if (!await isChromeCdpReady(cdpUrl, 500)) {
     const stderrOutput = Buffer.concat(stderrChunks).toString("utf8").trim();
@@ -1551,6 +1575,11 @@ ${stderrOutput.slice(0, 2e3)}` : "";
       proc.kill("SIGKILL");
     } catch {
     }
+    try {
+      const lockFile = path.join(userDataDir, "SingletonLock");
+      if (fs.existsSync(lockFile)) fs.unlinkSync(lockFile);
+    } catch {
+    }
     throw new Error(`Failed to start Chrome CDP on port ${String(cdpPort)}.${sandboxHint}${stderrHint}`);
   }
   proc.stderr.off("data", onStderr);
@@ -1569,19 +1598,13 @@ ${stderrOutput.slice(0, 2e3)}` : "";
 async function stopChrome(running, timeoutMs = 2500) {
   const proc = running.proc;
   if (proc.exitCode !== null) return;
-  try {
-    proc.kill("SIGTERM");
-  } catch {
-  }
+  killProcessTree(proc, "SIGTERM");
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
     if (proc.exitCode !== null) return;
     await new Promise((r) => setTimeout(r, 100));
   }
-  try {
-    proc.kill("SIGKILL");
-  } catch {
-  }
+  killProcessTree(proc, "SIGKILL");
 }
 
 // src/stealth.ts
@@ -1654,6 +1677,9 @@ var STEALTH_SCRIPT = `(function() {
   });
 
   // \u2500\u2500 4. window.chrome \u2500\u2500
+  // Stub the chrome.runtime API surface that detection scripts probe for.
+  // Only applied when the real chrome.runtime.connect is absent (headless/CDP mode).
+  // The stubs are intentionally non-functional \u2014 they exist solely to pass presence checks.
   p(function() {
     if (window.chrome && window.chrome.runtime && window.chrome.runtime.connect) return;
 
@@ -1704,6 +1730,9 @@ var STEALTH_SCRIPT = `(function() {
   });
 
   // \u2500\u2500 6. WebGL vendor / renderer \u2500\u2500
+  // Hardcoded to Intel Iris \u2014 the most common discrete GPU on macOS. These strings
+  // are fingerprinting targets; a more sophisticated approach would randomize per-session,
+  // but static values are sufficient to avoid the default "Google SwiftShader" headless signal.
   p(function() {
     var h = {
       apply: function(target, self, args) {
@@ -1839,7 +1868,7 @@ function ensurePageState(page) {
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         location: msg.location()
       });
-      if (state.console.length > MAX_CONSOLE_MESSAGES) state.console.shift();
+      if (state.console.length > MAX_CONSOLE_MESSAGES + 50) state.console.splice(0, 50);
     });
     page.on("pageerror", (err) => {
       state.errors.push({
@@ -1848,7 +1877,7 @@ function ensurePageState(page) {
         stack: err.stack !== void 0 && err.stack !== "" ? err.stack : void 0,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
-      if (state.errors.length > MAX_PAGE_ERRORS) state.errors.shift();
+      if (state.errors.length > MAX_PAGE_ERRORS + 20) state.errors.splice(0, 20);
     });
     page.on("request", (req) => {
       state.nextRequestId += 1;
@@ -1861,7 +1890,7 @@ function ensurePageState(page) {
         url: req.url(),
         resourceType: req.resourceType()
       });
-      if (state.requests.length > MAX_NETWORK_REQUESTS) state.requests.shift();
+      if (state.requests.length > MAX_NETWORK_REQUESTS + 50) state.requests.splice(0, 50);
     });
     page.on("response", (resp) => {
       const req = resp.request();
@@ -1935,31 +1964,40 @@ function setDialogHandlerOnPage(page, handler) {
   const state = ensurePageState(page);
   state.dialogHandler = handler;
 }
-function applyStealthToPage(page) {
-  page.evaluate(STEALTH_SCRIPT).catch((e) => {
+async function applyStealthToPage(page) {
+  try {
+    await page.evaluate(STEALTH_SCRIPT);
+  } catch (e) {
     if (process.env.DEBUG !== void 0 && process.env.DEBUG !== "")
       console.warn("[browserclaw] stealth evaluate failed:", e instanceof Error ? e.message : String(e));
-  });
+  }
 }
-function observeContext(context) {
+async function observeContext(context) {
   if (observedContexts.has(context)) return;
   observedContexts.add(context);
   ensureContextState(context);
-  context.addInitScript(STEALTH_SCRIPT).catch((e) => {
+  try {
+    await context.addInitScript(STEALTH_SCRIPT);
+  } catch (e) {
     if (process.env.DEBUG !== void 0 && process.env.DEBUG !== "")
       console.warn("[browserclaw] stealth initScript failed:", e instanceof Error ? e.message : String(e));
-  });
+  }
   for (const page of context.pages()) {
     ensurePageState(page);
-    applyStealthToPage(page);
+    await applyStealthToPage(page);
   }
-  context.on("page", (page) => {
+  const onPage = (page) => {
     ensurePageState(page);
-    applyStealthToPage(page);
+    applyStealthToPage(page).catch(() => {
+    });
+  };
+  context.on("page", onPage);
+  context.once("close", () => {
+    context.off("page", onPage);
   });
 }
-function observeBrowser(browser) {
-  for (const context of browser.contexts()) observeContext(context);
+async function observeBrowser(browser) {
+  for (const context of browser.contexts()) await observeContext(context);
 }
 function toAIFriendlyError(error, selector) {
   const message = error instanceof Error ? error.message : String(error);
@@ -1994,6 +2032,7 @@ function normalizeTimeoutMs(timeoutMs, fallback, maxMs = 12e4) {
 }
 
 // src/ref-resolver.ts
+var REFS_STALENESS_THRESHOLD_MS = 3e4;
 var roleRefsByTarget = /* @__PURE__ */ new Map();
 var MAX_ROLE_REFS_CACHE = 50;
 function normalizeCdpUrl(raw) {
@@ -2008,7 +2047,8 @@ function rememberRoleRefsForTarget(opts) {
   roleRefsByTarget.set(roleRefsKey(opts.cdpUrl, targetId), {
     refs: opts.refs,
     ...opts.frameSelector !== void 0 && opts.frameSelector !== "" ? { frameSelector: opts.frameSelector } : {},
-    ...opts.mode !== void 0 ? { mode: opts.mode } : {}
+    ...opts.mode !== void 0 ? { mode: opts.mode } : {},
+    storedAt: Date.now()
   });
   while (roleRefsByTarget.size > MAX_ROLE_REFS_CACHE) {
     const first = roleRefsByTarget.keys().next();
@@ -2021,6 +2061,7 @@ function storeRoleRefsForTarget(opts) {
   state.roleRefs = opts.refs;
   state.roleRefsFrameSelector = opts.frameSelector;
   state.roleRefsMode = opts.mode;
+  state.roleRefsStoredAt = Date.now();
   if (opts.targetId === void 0 || opts.targetId.trim() === "") return;
   rememberRoleRefsForTarget({
     cdpUrl: opts.cdpUrl,
@@ -2030,17 +2071,6 @@ function storeRoleRefsForTarget(opts) {
     mode: opts.mode
   });
 }
-function restoreRoleRefsForTarget(opts) {
-  const targetId = opts.targetId?.trim() ?? "";
-  if (targetId === "") return;
-  const entry = roleRefsByTarget.get(roleRefsKey(opts.cdpUrl, targetId));
-  if (!entry) return;
-  const state = ensurePageState(opts.page);
-  if (state.roleRefs) return;
-  state.roleRefs = entry.refs;
-  state.roleRefsFrameSelector = entry.frameSelector;
-  state.roleRefsMode = entry.mode;
-}
 function clearRoleRefsForCdpUrl(cdpUrl) {
   const normalized = normalizeCdpUrl(cdpUrl);
   for (const key of roleRefsByTarget.keys()) {
@@ -2079,6 +2109,14 @@ function refLocator(page, ref) {
   if (normalized.trim() === "") throw new Error("ref is required");
   if (/^e\d+$/.test(normalized)) {
     const state = getPageState(page);
+    if (state?.roleRefsStoredAt !== void 0) {
+      const ageMs = Date.now() - state.roleRefsStoredAt;
+      if (ageMs > REFS_STALENESS_THRESHOLD_MS) {
+        console.warn(
+          `[browserclaw] refs are ${String(Math.round(ageMs / 1e3))}s old \u2014 consider re-snapshotting for fresh refs`
+        );
+      }
+    }
     if (state?.roleRefsMode === "aria") {
       return (state.roleRefsFrameSelector !== void 0 && state.roleRefsFrameSelector !== "" ? page.frameLocator(state.roleRefsFrameSelector) : page).locator(`aria-ref=${normalized}`);
     }
@@ -2127,14 +2165,16 @@ function appendCdpPath2(cdpUrl, cdpPath) {
 }
 async function withPlaywrightPageCdpSession(page, fn) {
   const CDP_SESSION_TIMEOUT_MS = 1e4;
+  let timer;
   const session = await Promise.race([
     page.context().newCDPSession(page),
     new Promise((_, reject) => {
-      setTimeout(() => {
+      timer = setTimeout(() => {
         reject(new Error("newCDPSession timed out after 10s"));
       }, CDP_SESSION_TIMEOUT_MS);
     })
   ]);
+  clearTimeout(timer);
   try {
     return await fn(session);
   } finally {
@@ -2160,8 +2200,10 @@ function isLoopbackCdpUrl(url) {
   }
 }
 var envMutexPromise = Promise.resolve();
+var envMutexDepth = 0;
 async function withNoProxyForCdpUrl(url, fn) {
   if (!isLoopbackCdpUrl(url) || !hasProxyEnvConfigured()) return fn();
+  if (envMutexDepth > 0) return fn();
   const prev = envMutexPromise;
   let release = () => {
   };
@@ -2182,9 +2224,11 @@ async function withNoProxyForCdpUrl(url, fn) {
   const applied = current ? `${current},${LOOPBACK_ENTRIES}` : LOOPBACK_ENTRIES;
   process.env.NO_PROXY = applied;
   process.env.no_proxy = applied;
+  envMutexDepth += 1;
   try {
     return await fn();
   } finally {
+    envMutexDepth -= 1;
     if (process.env.NO_PROXY === applied) {
       if (savedNoProxy !== void 0) process.env.NO_PROXY = savedNoProxy;
       else delete process.env.NO_PROXY;
@@ -2215,12 +2259,28 @@ function getHeadersWithAuth(endpoint, baseHeaders = {}) {
 }
 var cachedByCdpUrl = /* @__PURE__ */ new Map();
 var connectingByCdpUrl = /* @__PURE__ */ new Map();
+var connectionMutex = Promise.resolve();
+async function withConnectionLock(fn) {
+  const prev = connectionMutex;
+  let release = () => {
+  };
+  connectionMutex = new Promise((r) => {
+    release = r;
+  });
+  await prev;
+  try {
+    return await fn();
+  } finally {
+    release();
+  }
+}
 var BlockedBrowserTargetError = class extends Error {
   constructor() {
     super("Browser target is unavailable after SSRF policy blocked its navigation.");
     this.name = "BlockedBrowserTargetError";
   }
 };
+var MAX_BLOCKED_TARGETS = 200;
 var blockedTargetsByCdpUrl = /* @__PURE__ */ new Set();
 var blockedPageRefsByCdpUrl = /* @__PURE__ */ new Map();
 function blockedTargetKey(cdpUrl, targetId) {
@@ -2235,6 +2295,10 @@ function markTargetBlocked(cdpUrl, targetId) {
   const normalized = targetId?.trim() ?? "";
   if (normalized === "") return;
   blockedTargetsByCdpUrl.add(blockedTargetKey(cdpUrl, normalized));
+  if (blockedTargetsByCdpUrl.size > MAX_BLOCKED_TARGETS) {
+    const first = blockedTargetsByCdpUrl.values().next();
+    if (first.done !== true) blockedTargetsByCdpUrl.delete(first.value);
+  }
 }
 function clearBlockedTarget(cdpUrl, targetId) {
   const normalized = targetId?.trim() ?? "";
@@ -2248,6 +2312,16 @@ function hasBlockedTargetsForCdpUrl(cdpUrl) {
   }
   return false;
 }
+function clearBlockedTargetsForCdpUrl(cdpUrl) {
+  if (cdpUrl === void 0) {
+    blockedTargetsByCdpUrl.clear();
+    return;
+  }
+  const prefix = `${normalizeCdpUrl(cdpUrl)}::`;
+  for (const key of blockedTargetsByCdpUrl) {
+    if (key.startsWith(prefix)) blockedTargetsByCdpUrl.delete(key);
+  }
+}
 function blockedPageRefsForCdpUrl(cdpUrl) {
   const normalized = normalizeCdpUrl(cdpUrl);
   const existing = blockedPageRefsByCdpUrl.get(normalized);
@@ -2262,6 +2336,13 @@ function isBlockedPageRef(cdpUrl, page) {
 function markPageRefBlocked(cdpUrl, page) {
   blockedPageRefsForCdpUrl(cdpUrl).add(page);
 }
+function clearBlockedPageRefsForCdpUrl(cdpUrl) {
+  if (cdpUrl === void 0) {
+    blockedPageRefsByCdpUrl.clear();
+    return;
+  }
+  blockedPageRefsByCdpUrl.delete(normalizeCdpUrl(cdpUrl));
+}
 function clearBlockedPageRef(cdpUrl, page) {
   blockedPageRefsByCdpUrl.get(normalizeCdpUrl(cdpUrl))?.delete(page);
 }
@@ -2275,64 +2356,98 @@ async function connectBrowser(cdpUrl, authToken) {
   if (existing_cached) return existing_cached;
   const existing = connectingByCdpUrl.get(normalized);
   if (existing) return await existing;
-  const connectWithRetry = async () => {
-    let lastErr;
-    for (let attempt = 0; attempt < 3; attempt++) {
-      try {
-        const timeout = 5e3 + attempt * 2e3;
-        const endpoint = await getChromeWebSocketUrl(normalized, timeout, authToken).catch(() => null) ?? normalized;
-        const headers = getHeadersWithAuth(endpoint);
-        if (authToken !== void 0 && authToken !== "" && !headers.Authorization)
-          headers.Authorization = `Bearer ${authToken}`;
-        const browser = await withNoProxyForCdpUrl(
-          endpoint,
-          () => chromium.connectOverCDP(endpoint, { timeout, headers })
-        );
-        const onDisconnected = () => {
-          if (cachedByCdpUrl.get(normalized)?.browser === browser) {
-            cachedByCdpUrl.delete(normalized);
-            clearRoleRefsForCdpUrl(normalized);
+  return withConnectionLock(async () => {
+    const rechecked = cachedByCdpUrl.get(normalized);
+    if (rechecked) return rechecked;
+    const recheckPending = connectingByCdpUrl.get(normalized);
+    if (recheckPending) return await recheckPending;
+    const connectWithRetry = async () => {
+      let lastErr;
+      for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+          const timeout = 5e3 + attempt * 2e3;
+          const endpoint = await getChromeWebSocketUrl(normalized, timeout, authToken).catch(() => null) ?? normalized;
+          const headers = getHeadersWithAuth(endpoint);
+          if (authToken !== void 0 && authToken !== "" && !headers.Authorization)
+            headers.Authorization = `Bearer ${authToken}`;
+          const browser = await withNoProxyForCdpUrl(
+            endpoint,
+            () => chromium.connectOverCDP(endpoint, { timeout, headers })
+          );
+          const onDisconnected = () => {
+            if (cachedByCdpUrl.get(normalized)?.browser === browser) {
+              cachedByCdpUrl.delete(normalized);
+              clearRoleRefsForCdpUrl(normalized);
+            }
+          };
+          const connected = { browser, cdpUrl: normalized, onDisconnected };
+          cachedByCdpUrl.set(normalized, connected);
+          await observeBrowser(browser);
+          browser.on("disconnected", onDisconnected);
+          return connected;
+        } catch (err) {
+          lastErr = err;
+          if ((err instanceof Error ? err.message : String(err)).includes("rate limit")) {
+            await new Promise((r) => setTimeout(r, 1e3 + attempt * 1e3));
+            continue;
           }
-        };
-        const connected = { browser, cdpUrl: normalized, onDisconnected };
-        cachedByCdpUrl.set(normalized, connected);
-        observeBrowser(browser);
-        browser.on("disconnected", onDisconnected);
-        return connected;
-      } catch (err) {
-        lastErr = err;
-        if ((err instanceof Error ? err.message : String(err)).includes("rate limit")) break;
-        await new Promise((r) => setTimeout(r, 250 + attempt * 250));
+          await new Promise((r) => setTimeout(r, 250 + attempt * 250));
+        }
       }
-    }
-    throw lastErr instanceof Error ? lastErr : new Error("CDP connect failed");
-  };
-  const promise = connectWithRetry().finally(() => {
-    connectingByCdpUrl.delete(normalized);
+      throw lastErr instanceof Error ? lastErr : new Error("CDP connect failed");
+    };
+    const promise = connectWithRetry().finally(() => {
+      connectingByCdpUrl.delete(normalized);
+    });
+    connectingByCdpUrl.set(normalized, promise);
+    return await promise;
   });
-  connectingByCdpUrl.set(normalized, promise);
-  return await promise;
 }
 async function disconnectBrowser() {
-  if (connectingByCdpUrl.size) {
-    for (const p of connectingByCdpUrl.values()) {
-      try {
-        await p;
-      } catch (err) {
-        console.warn(
-          `[browserclaw] disconnectBrowser: pending connect failed: ${err instanceof Error ? err.message : String(err)}`
-        );
+  return withConnectionLock(async () => {
+    if (connectingByCdpUrl.size) {
+      for (const p of connectingByCdpUrl.values()) {
+        try {
+          await p;
+        } catch (err) {
+          console.warn(
+            `[browserclaw] disconnectBrowser: pending connect failed: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
       }
     }
-  }
-  for (const cur of cachedByCdpUrl.values()) {
-    clearRoleRefsForCdpUrl(cur.cdpUrl);
-    if (cur.onDisconnected && typeof cur.browser.off === "function")
-      cur.browser.off("disconnected", cur.onDisconnected);
-    await cur.browser.close().catch(() => {
+    for (const cur of cachedByCdpUrl.values()) {
+      clearRoleRefsForCdpUrl(cur.cdpUrl);
+      if (cur.onDisconnected && typeof cur.browser.off === "function")
+        cur.browser.off("disconnected", cur.onDisconnected);
+      await cur.browser.close().catch(() => {
+      });
+    }
+    cachedByCdpUrl.clear();
+    clearBlockedTargetsForCdpUrl();
+    clearBlockedPageRefsForCdpUrl();
+  });
+}
+async function closePlaywrightBrowserConnection(opts) {
+  if (opts?.cdpUrl !== void 0 && opts.cdpUrl !== "") {
+    return withConnectionLock(async () => {
+      const cdpUrl = opts.cdpUrl;
+      if (cdpUrl === void 0 || cdpUrl === "") return;
+      const normalized = normalizeCdpUrl(cdpUrl);
+      clearBlockedTargetsForCdpUrl(normalized);
+      clearBlockedPageRefsForCdpUrl(normalized);
+      const cur = cachedByCdpUrl.get(normalized);
+      cachedByCdpUrl.delete(normalized);
+      connectingByCdpUrl.delete(normalized);
+      if (!cur) return;
+      if (cur.onDisconnected && typeof cur.browser.off === "function")
+        cur.browser.off("disconnected", cur.onDisconnected);
+      await cur.browser.close().catch(() => {
+      });
     });
+  } else {
+    await disconnectBrowser();
   }
-  cachedByCdpUrl.clear();
 }
 function cdpSocketNeedsAttach(wsUrl) {
   try {
@@ -2441,7 +2556,7 @@ async function forceDisconnectPlaywrightConnection(opts) {
     await tryTerminateExecutionViaCdp(normalized, targetId).catch(() => {
     });
   }
-  cur.browser.close().catch(() => {
+  await cur.browser.close().catch(() => {
   });
 }
 var forceDisconnectPlaywrightForTarget = forceDisconnectPlaywrightConnection;
@@ -2452,17 +2567,13 @@ var pageTargetIdCache = /* @__PURE__ */ new WeakMap();
 async function pageTargetId(page) {
   const cached = pageTargetIdCache.get(page);
   if (cached !== void 0) return cached;
-  const session = await page.context().newCDPSession(page);
-  try {
+  return withPlaywrightPageCdpSession(page, async (session) => {
     const info = await session.send("Target.getTargetInfo");
     const targetInfo = info.targetInfo;
     const id = (targetInfo?.targetId ?? "").trim() || null;
     if (id !== null) pageTargetIdCache.set(page, id);
     return id;
-  } finally {
-    await session.detach().catch(() => {
-    });
-  }
+  });
 }
 function matchPageByTargetList(pages, targets, targetId) {
   const target = targets.find((entry) => entry.id === targetId);
@@ -2498,7 +2609,6 @@ async function findPageByTargetId(browser, targetId, cdpUrl) {
       }
     })
   );
-  const resolvedViaCdp = results.some(({ tid }) => tid !== null);
   const matched = results.find(({ tid }) => tid !== null && tid !== "" && tid === targetId);
   if (matched) return matched.page;
   if (cdpUrl !== void 0 && cdpUrl !== "") {
@@ -2507,7 +2617,6 @@ async function findPageByTargetId(browser, targetId, cdpUrl) {
     } catch {
     }
   }
-  if (!resolvedViaCdp && pages.length === 1) return pages[0] ?? null;
   return null;
 }
 async function partitionAccessiblePages(opts) {
@@ -2550,12 +2659,14 @@ async function getPageForTargetId(opts) {
   if (opts.targetId === void 0 || opts.targetId === "") return first;
   const found = await findPageByTargetId(browser, opts.targetId, opts.cdpUrl);
   if (!found) {
-    if (pages.length === 1) return first;
     throw new BrowserTabNotFoundError(
       `Tab not found (targetId: ${opts.targetId}). Call browser.tabs() to list open tabs.`
     );
   }
   if (isBlockedPageRef(opts.cdpUrl, found)) throw new BlockedBrowserTargetError();
+  const foundTargetId = await pageTargetId(found).catch(() => null);
+  if (foundTargetId !== null && foundTargetId !== "" && isBlockedTarget(opts.cdpUrl, foundTargetId))
+    throw new BlockedBrowserTargetError();
   return found;
 }
 async function resolvePageByTargetIdOrThrow(opts) {
@@ -2567,7 +2678,6 @@ async function resolvePageByTargetIdOrThrow(opts) {
 async function getRestoredPageForTarget(opts) {
   const page = await getPageForTargetId(opts);
   ensurePageState(page);
-  restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
   return page;
 }
 
@@ -2621,10 +2731,11 @@ var BROWSER_EVALUATOR = new Function(
     "  catch (_) { candidate = (0, eval)(fnBody); }",
     '  var result = typeof candidate === "function" ? candidate() : candidate;',
     '  if (result && typeof result.then === "function") {',
+    "    var tid;",
     "    return Promise.race([",
-    "      result,",
+    "      result.then(function(v) { clearTimeout(tid); return v; }, function(e) { clearTimeout(tid); throw e; }),",
     "      new Promise(function(_, reject) {",
-    '        setTimeout(function() { reject(new Error("evaluate timed out after " + timeoutMs + "ms")); }, timeoutMs);',
+    '        tid = setTimeout(function() { reject(new Error("evaluate timed out after " + timeoutMs + "ms")); }, timeoutMs);',
     "      })",
     "    ]);",
     "  }",
@@ -2646,10 +2757,11 @@ var ELEMENT_EVALUATOR = new Function(
     "  catch (_) { candidate = (0, eval)(fnBody); }",
     '  var result = typeof candidate === "function" ? candidate(el) : candidate;',
     '  if (result && typeof result.then === "function") {',
+    "    var tid;",
     "    return Promise.race([",
-    "      result,",
+    "      result.then(function(v) { clearTimeout(tid); return v; }, function(e) { clearTimeout(tid); throw e; }),",
     "      new Promise(function(_, reject) {",
-    '        setTimeout(function() { reject(new Error("evaluate timed out after " + timeoutMs + "ms")); }, timeoutMs);',
+    '        tid = setTimeout(function() { reject(new Error("evaluate timed out after " + timeoutMs + "ms")); }, timeoutMs);',
     "      })",
     "    ]);",
     "  }",
@@ -2664,10 +2776,8 @@ async function evaluateViaPlaywright(opts) {
   if (!fnText) throw new Error("function is required");
   const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
   ensurePageState(page);
-  restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
   const outerTimeout = normalizeTimeoutMs(opts.timeoutMs, 2e4);
-  let evaluateTimeout = Math.max(1e3, Math.min(12e4, outerTimeout - 500));
-  evaluateTimeout = Math.min(evaluateTimeout, outerTimeout);
+  const evaluateTimeout = Math.max(1e3, Math.min(12e4, outerTimeout - 1e3));
   const signal = opts.signal;
   let abortListener;
   let abortReject;
@@ -2681,10 +2791,16 @@ async function evaluateViaPlaywright(opts) {
   }
   if (signal !== void 0) {
     const disconnect = () => {
-      forceDisconnectPlaywrightConnection({
-        cdpUrl: opts.cdpUrl,
-        targetId: opts.targetId}).catch(() => {
-      });
+      const targetId = opts.targetId?.trim() ?? "";
+      if (targetId !== "") {
+        tryTerminateExecutionViaCdp(opts.cdpUrl, targetId).catch(() => {
+        });
+      } else {
+        console.warn("[browserclaw] evaluate abort: no targetId, forcing full disconnect");
+        forceDisconnectPlaywrightConnection({
+          cdpUrl: opts.cdpUrl}).catch(() => {
+        });
+      }
     };
     if (signal.aborted) {
       disconnect();
@@ -2720,6 +2836,8 @@ async function evaluateViaPlaywright(opts) {
     );
   } finally {
     if (signal && abortListener) signal.removeEventListener("abort", abortListener);
+    abortReject = void 0;
+    abortListener = void 0;
   }
 }
 
@@ -2912,7 +3030,7 @@ function isBlockedHostnameOrIp(hostname, policy) {
 function isPrivateIpAddress(address, policy) {
   let normalized = address.trim().toLowerCase();
   if (normalized.startsWith("[") && normalized.endsWith("]")) normalized = normalized.slice(1, -1);
-  if (!normalized) return false;
+  if (!normalized) return true;
   const blockOptions = resolveIpv4SpecialUseBlockOptions(policy);
   const strictIp = parseCanonicalIpAddress(normalized);
   if (strictIp) {
@@ -2999,6 +3117,25 @@ function createPinnedLookup(params) {
     cb(null, chosen.address, chosen.family);
   });
 }
+var DNS_CACHE_TTL_MS = 3e4;
+var MAX_DNS_CACHE_SIZE = 100;
+var dnsCache = /* @__PURE__ */ new Map();
+function getCachedDnsResult(hostname) {
+  const entry = dnsCache.get(hostname);
+  if (!entry) return void 0;
+  if (Date.now() > entry.expiresAt) {
+    dnsCache.delete(hostname);
+    return void 0;
+  }
+  return entry.result;
+}
+function cacheDnsResult(hostname, result) {
+  dnsCache.set(hostname, { result, expiresAt: Date.now() + DNS_CACHE_TTL_MS });
+  if (dnsCache.size > MAX_DNS_CACHE_SIZE) {
+    const first = dnsCache.keys().next();
+    if (first.done !== true) dnsCache.delete(first.value);
+  }
+}
 async function resolvePinnedHostnameWithPolicy(hostname, params = {}) {
   const normalized = normalizeHostname(hostname);
   if (!normalized) throw new InvalidBrowserNavigationUrlError(`Invalid hostname: "${hostname}"`);
@@ -3017,6 +3154,8 @@ async function resolvePinnedHostnameWithPolicy(hostname, params = {}) {
       );
     }
   }
+  const cached = getCachedDnsResult(normalized);
+  if (cached) return cached;
   const lookupFn = params.lookupFn ?? lookup$1;
   let results;
   try {
@@ -3046,11 +3185,13 @@ async function resolvePinnedHostnameWithPolicy(hostname, params = {}) {
       `Navigation to internal/loopback address blocked: unable to resolve "${hostname}".`
     );
   }
-  return {
+  const pinned = {
     hostname: normalized,
     addresses,
     lookup: createPinnedLookup({ hostname: normalized, addresses })
   };
+  cacheDnsResult(normalized, pinned);
+  return pinned;
 }
 async function assertBrowserNavigationAllowed(opts) {
   const rawUrl = opts.url.trim();
@@ -3204,13 +3345,27 @@ function buildSiblingTempPath(targetPath) {
   return join(dirname(targetPath), `.browserclaw-output-${id}-${safeTail}.part`);
 }
 async function writeViaSiblingTempPath(params) {
-  const rootDir = await realpath(resolve(params.rootDir)).catch(() => resolve(params.rootDir));
+  let rootDir;
+  try {
+    rootDir = await realpath(resolve(params.rootDir));
+  } catch {
+    console.warn(`[browserclaw] writeViaSiblingTempPath: rootDir realpath failed, using lexical resolve`);
+    rootDir = resolve(params.rootDir);
+  }
   const requestedTargetPath = resolve(params.targetPath);
   const targetPath = await realpath(dirname(requestedTargetPath)).then((realDir) => join(realDir, basename(requestedTargetPath))).catch(() => requestedTargetPath);
   const relativeTargetPath = relative(rootDir, targetPath);
   if (!relativeTargetPath || relativeTargetPath === ".." || relativeTargetPath.startsWith(`..${sep}`) || isAbsolute(relativeTargetPath)) {
     throw new Error("Target path is outside the allowed root");
   }
+  try {
+    const stat = await lstat(targetPath);
+    if (stat.isSymbolicLink()) {
+      throw new Error(`Unsafe output path: "${params.targetPath}" is a symbolic link.`);
+    }
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
   const tempPath = buildSiblingTempPath(targetPath);
   let renameSucceeded = false;
   try {
@@ -3232,6 +3387,9 @@ async function assertBrowserNavigationResultAllowed(opts) {
   } catch {
     return;
   }
+  if (parsed.protocol === "data:" || parsed.protocol === "blob:") {
+    throw new InvalidBrowserNavigationUrlError(`Navigation result blocked: "${parsed.protocol}" URLs are not allowed.`);
+  }
   if (NETWORK_NAVIGATION_PROTOCOLS.has(parsed.protocol) || isAllowedNonNetworkNavigationUrl(parsed)) {
     await assertBrowserNavigationAllowed(opts);
   }
@@ -3349,9 +3507,10 @@ async function clickViaPlaywright(opts) {
     if (checkableRole && opts.doubleClick !== true && ariaCheckedBefore !== void 0) {
       const POLL_INTERVAL_MS = 50;
       const POLL_TIMEOUT_MS = 500;
+      const ATTR_TIMEOUT_MS = Math.min(timeout, POLL_TIMEOUT_MS);
       let changed = false;
       for (let elapsed = 0; elapsed < POLL_TIMEOUT_MS; elapsed += POLL_INTERVAL_MS) {
-        const current = await locator.getAttribute("aria-checked", { timeout }).catch(() => void 0);
+        const current = await locator.getAttribute("aria-checked", { timeout: ATTR_TIMEOUT_MS }).catch(() => void 0);
         if (current === void 0 || current !== ariaCheckedBefore) {
           changed = true;
           break;
@@ -3428,6 +3587,7 @@ async function dragViaPlaywright(opts) {
 async function fillFormViaPlaywright(opts) {
   const page = await getRestoredPageForTarget(opts);
   const timeout = resolveInteractionTimeoutMs(opts.timeoutMs);
+  let filledCount = 0;
   for (const field of opts.fields) {
     const ref = field.ref.trim();
     const type = (typeof field.type === "string" ? field.type.trim() : "") || "text";
@@ -3446,16 +3606,24 @@ async function fillFormViaPlaywright(opts) {
         try {
           await setCheckedViaEvaluate(locator, checked);
         } catch (err) {
-          throw toAIFriendlyError(err, ref);
+          const friendly = toAIFriendlyError(err, ref);
+          throw new Error(
+            `Failed at field "${ref}" (${String(filledCount)}/${String(opts.fields.length)} filled): ${friendly.message}`
+          );
         }
       }
+      filledCount += 1;
       continue;
     }
     try {
       await locator.fill(value, { timeout });
     } catch (err) {
-      throw toAIFriendlyError(err, ref);
+      const friendly = toAIFriendlyError(err, ref);
+      throw new Error(
+        `Failed at field "${ref}" (${String(filledCount)}/${String(opts.fields.length)} filled): ${friendly.message}`
+      );
     }
+    filledCount += 1;
   }
 }
 async function scrollIntoViewViaPlaywright(opts) {
@@ -3521,16 +3689,22 @@ async function armDialogViaPlaywright(opts) {
   const timeout = normalizeTimeoutMs(opts.timeoutMs, 12e4);
   state.armIdDialog = bumpDialogArmId(state);
   const armId = state.armIdDialog;
+  const resetArm = () => {
+    if (state.armIdDialog === armId) state.armIdDialog = 0;
+  };
+  page.once("close", resetArm);
   page.waitForEvent("dialog", { timeout }).then(async (dialog) => {
     if (state.armIdDialog !== armId) return;
     try {
       if (opts.accept) await dialog.accept(opts.promptText);
       else await dialog.dismiss();
     } finally {
-      if (state.armIdDialog === armId) state.armIdDialog = 0;
+      resetArm();
+      page.off("close", resetArm);
     }
   }).catch(() => {
-    if (state.armIdDialog === armId) state.armIdDialog = 0;
+    resetArm();
+    page.off("close", resetArm);
   });
 }
 async function armFileUploadViaPlaywright(opts) {
@@ -3539,6 +3713,10 @@ async function armFileUploadViaPlaywright(opts) {
   const timeout = normalizeTimeoutMs(opts.timeoutMs, 12e4);
   state.armIdUpload = bumpUploadArmId(state);
   const armId = state.armIdUpload;
+  const resetArm = () => {
+    if (state.armIdUpload === armId) state.armIdUpload = 0;
+  };
+  page.once("close", resetArm);
   page.waitForEvent("filechooser", { timeout }).then(async (fileChooser) => {
     if (state.armIdUpload !== armId) return;
     if (opts.paths === void 0 || opts.paths.length === 0) {
@@ -3570,9 +3748,18 @@ async function armFileUploadViaPlaywright(opts) {
           el.dispatchEvent(new Event("change", { bubbles: true }));
         });
       }
-    } catch {
+    } catch (e) {
+      console.warn(
+        `[browserclaw] armFileUpload: dispatch events failed: ${e instanceof Error ? e.message : String(e)}`
+      );
     }
-  }).catch(() => {
+  }).catch((e) => {
+    console.warn(
+      `[browserclaw] armFileUpload: filechooser wait failed: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }).finally(() => {
+    resetArm();
+    page.off("close", resetArm);
   });
 }
 
@@ -3592,7 +3779,7 @@ function clearRecordingContext(cdpUrl) {
 }
 async function createRecordingContext(browser, cdpUrl, recordVideo) {
   const context = await browser.newContext({ recordVideo });
-  observeContext(context);
+  await observeContext(context);
   recordingContexts.set(cdpUrl, context);
   context.on("close", () => recordingContexts.delete(cdpUrl));
   return context;
@@ -3647,6 +3834,11 @@ async function gotoPageWithNavigationGuard(opts) {
       await route.continue();
       return;
     }
+    const isRedirect = request.redirectedFrom() !== null;
+    if (!isRedirect && request.url() !== opts.url) {
+      await route.continue();
+      return;
+    }
     try {
       await assertBrowserNavigationAllowed({ url: request.url(), ...navigationPolicy });
     } catch (err) {
@@ -3698,6 +3890,7 @@ async function navigateViaPlaywright(opts) {
     response = await navigate();
   } catch (err) {
     if (!isRetryableNavigateError(err)) throw err;
+    recordingContexts.delete(opts.cdpUrl);
     await forceDisconnectPlaywrightConnection({
       cdpUrl: opts.cdpUrl,
       targetId: opts.targetId}).catch(() => {
@@ -3757,6 +3950,7 @@ async function createPageViaPlaywright(opts) {
       });
     } catch (err) {
       if (isPolicyDenyNavigationError(err) || err instanceof BlockedBrowserTargetError) throw err;
+      console.warn(`[browserclaw] createPage navigation failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     await assertPageNavigationCompletedSafely({
       cdpUrl: opts.cdpUrl,
@@ -3843,39 +4037,46 @@ var MAX_WAIT_TIME_MS = 3e4;
 async function waitForViaPlaywright(opts) {
   const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
   ensurePageState(page);
-  const timeout = normalizeTimeoutMs(opts.timeoutMs, 2e4);
+  const totalTimeout = normalizeTimeoutMs(opts.timeoutMs, 2e4);
+  const deadline = Date.now() + totalTimeout;
+  const remaining = () => Math.max(500, deadline - Date.now());
   if (typeof opts.timeMs === "number" && Number.isFinite(opts.timeMs)) {
     await page.waitForTimeout(resolveBoundedDelayMs(opts.timeMs, "wait timeMs", MAX_WAIT_TIME_MS));
   }
   if (opts.text !== void 0 && opts.text !== "") {
-    await page.waitForFunction((text) => (document.body?.innerText ?? "").includes(text), opts.text, { timeout });
+    await page.waitForFunction((text) => (document.body?.innerText ?? "").includes(text), opts.text, {
+      timeout: remaining()
+    });
   }
   if (opts.textGone !== void 0 && opts.textGone !== "") {
-    await page.waitForFunction((text) => !(document.body?.innerText ?? "").includes(text), opts.textGone, { timeout });
+    await page.waitForFunction((text) => !(document.body?.innerText ?? "").includes(text), opts.textGone, {
+      timeout: remaining()
+    });
   }
   if (opts.selector !== void 0 && opts.selector !== "") {
     const selector = opts.selector.trim();
-    if (selector !== "") await page.locator(selector).first().waitFor({ state: "visible", timeout });
+    if (selector !== "") await page.locator(selector).first().waitFor({ state: "visible", timeout: remaining() });
   }
   if (opts.url !== void 0 && opts.url !== "") {
     const url = opts.url.trim();
-    if (url !== "") await page.waitForURL(url, { timeout });
+    if (url !== "") await page.waitForURL(url, { timeout: remaining() });
   }
   if (opts.loadState !== void 0) {
-    await page.waitForLoadState(opts.loadState, { timeout });
+    await page.waitForLoadState(opts.loadState, { timeout: remaining() });
   }
   if (opts.fn !== void 0) {
     if (typeof opts.fn === "function") {
-      await page.waitForFunction(opts.fn, opts.arg, { timeout });
+      await page.waitForFunction(opts.fn, opts.arg, { timeout: remaining() });
     } else {
       const fn = opts.fn.trim();
-      if (fn !== "") await page.waitForFunction(fn, opts.arg, { timeout });
+      if (fn !== "") await page.waitForFunction(fn, opts.arg, { timeout: remaining() });
     }
   }
 }
 
 // src/actions/batch.ts
 var MAX_BATCH_DEPTH = 5;
+var MAX_BATCH_TIMEOUT_MS = 3e5;
 var MAX_BATCH_ACTIONS = 100;
 async function executeSingleAction(action, cdpUrl, targetId, evaluateEnabled, depth = 0) {
   if (depth > MAX_BATCH_DEPTH) throw new Error(`Batch nesting depth exceeds maximum of ${String(MAX_BATCH_DEPTH)}`);
@@ -4023,13 +4224,19 @@ async function batchViaPlaywright(opts) {
     throw new Error(`Batch exceeds maximum of ${String(MAX_BATCH_ACTIONS)} actions`);
   const results = [];
   const evaluateEnabled = opts.evaluateEnabled !== false;
+  const deadline = Date.now() + MAX_BATCH_TIMEOUT_MS;
   for (const action of opts.actions) {
+    if (Date.now() > deadline) {
+      results.push({ ok: false, error: "Batch timeout exceeded" });
+      break;
+    }
     try {
       await executeSingleAction(action, opts.cdpUrl, opts.targetId, evaluateEnabled, depth);
       results.push({ ok: true });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       results.push({ ok: false, error: message });
+      if (err instanceof BrowserTabNotFoundError || err instanceof BlockedBrowserTargetError) break;
       if (opts.stopOnError !== false) break;
     }
   }
@@ -4047,8 +4254,10 @@ function createPageDownloadWaiter(page, timeoutMs) {
       handler = void 0;
     }
   };
+  let rejectPromise;
   return {
     promise: new Promise((resolve2, reject) => {
+      rejectPromise = reject;
       handler = (download) => {
         if (done) return;
         done = true;
@@ -4067,6 +4276,7 @@ function createPageDownloadWaiter(page, timeoutMs) {
       if (done) return;
       done = true;
       cleanup();
+      rejectPromise?.(new Error("Download waiter cancelled"));
     }
   };
 }
@@ -4098,12 +4308,11 @@ async function downloadViaPlaywright(opts) {
   await assertSafeOutputPath(opts.path, opts.allowedOutputRoots);
   const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
   const state = ensurePageState(page);
-  restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
   const timeout = normalizeTimeoutMs(opts.timeoutMs, 12e4);
   const outPath = opts.path.trim();
   if (!outPath) throw new Error("path is required");
-  state.armIdDownload = bumpDownloadArmId(state);
-  const armId = state.armIdDownload;
+  const armId = bumpDownloadArmId(state);
+  state.armIdDownload = armId;
   const waiter = createPageDownloadWaiter(page, timeout);
   try {
     const locator = refLocator(page, opts.ref);
@@ -4150,12 +4359,6 @@ async function setDeviceViaPlaywright(opts) {
   }
   const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
   ensurePageState(page);
-  if (device.viewport !== null) {
-    await page.setViewportSize({
-      width: device.viewport.width,
-      height: device.viewport.height
-    });
-  }
   await withPageScopedCdpClient({
     cdpUrl: opts.cdpUrl,
     page,
@@ -4183,11 +4386,24 @@ async function setDeviceViaPlaywright(opts) {
       }
     }
   });
+  if (device.viewport !== null) {
+    await page.setViewportSize({
+      width: device.viewport.width,
+      height: device.viewport.height
+    });
+  }
 }
 async function setExtraHTTPHeadersViaPlaywright(opts) {
   const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
   ensurePageState(page);
-  await page.context().setExtraHTTPHeaders(opts.headers);
+  await withPageScopedCdpClient({
+    cdpUrl: opts.cdpUrl,
+    page,
+    targetId: opts.targetId,
+    fn: async (send) => {
+      await send("Network.setExtraHTTPHeaders", { headers: opts.headers });
+    }
+  });
 }
 async function setGeolocationViaPlaywright(opts) {
   const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
@@ -4195,7 +4411,8 @@ async function setGeolocationViaPlaywright(opts) {
   const context = page.context();
   if (opts.clear === true) {
     await context.setGeolocation(null);
-    await context.clearPermissions().catch(() => {
+    await context.clearPermissions().catch((err) => {
+      console.warn(`[browserclaw] clearPermissions failed: ${err instanceof Error ? err.message : String(err)}`);
     });
     return;
   }
@@ -4497,7 +4714,6 @@ async function waitForRequestViaPlaywright(opts) {
 async function takeScreenshotViaPlaywright(opts) {
   const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
   ensurePageState(page);
-  restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
   const type = opts.type ?? "png";
   if (opts.ref !== void 0 && opts.ref !== "") {
     if (opts.fullPage === true) throw new Error("fullPage is not supported for element screenshots");
@@ -4512,7 +4728,6 @@ async function takeScreenshotViaPlaywright(opts) {
 async function screenshotWithLabelsViaPlaywright(opts) {
   const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
   ensurePageState(page);
-  restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
   const maxLabels = typeof opts.maxLabels === "number" && Number.isFinite(opts.maxLabels) ? Math.max(1, Math.floor(opts.maxLabels)) : 150;
   const type = opts.type ?? "png";
   const refs = opts.refs.slice(0, maxLabels);
@@ -4576,7 +4791,8 @@ async function screenshotWithLabelsViaPlaywright(opts) {
       document.querySelectorAll("[data-browserclaw-labels]").forEach((el) => {
         el.remove();
       });
-    }).catch(() => {
+    }).catch((err) => {
+      console.warn(`[browserclaw] label overlay cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
     });
   }
 }
@@ -4604,17 +4820,14 @@ async function traceStopViaPlaywright(opts) {
   if (!ctxState.traceActive) {
     throw new Error("No active trace. Start a trace before stopping it.");
   }
-  try {
-    await writeViaSiblingTempPath({
-      rootDir: dirname(opts.path),
-      targetPath: opts.path,
-      writeTemp: async (tempPath) => {
-        await context.tracing.stop({ path: tempPath });
-      }
-    });
-  } finally {
-    ctxState.traceActive = false;
-  }
+  ctxState.traceActive = false;
+  await writeViaSiblingTempPath({
+    rootDir: dirname(opts.path),
+    targetPath: opts.path,
+    writeTemp: async (tempPath) => {
+      await context.tracing.stop({ path: tempPath });
+    }
+  });
 }
 
 // src/snapshot/ref-map.ts
@@ -5175,17 +5388,27 @@ async function storageClearViaPlaywright(opts) {
 // src/browser.ts
 var CrawlPage = class {
   cdpUrl;
-  targetId;
+  _targetId;
   ssrfPolicy;
   /** @internal */
   constructor(cdpUrl, targetId, ssrfPolicy) {
     this.cdpUrl = cdpUrl;
-    this.targetId = targetId;
+    this._targetId = targetId;
     this.ssrfPolicy = ssrfPolicy;
   }
   /** The CDP target ID for this page. Use this to identify the page in multi-tab scenarios. */
   get id() {
-    return this.targetId;
+    return this._targetId;
+  }
+  /**
+   * Refresh the target ID by re-resolving the page from the browser.
+   * Useful after reconnection when the old target ID may be stale.
+   */
+  async refreshTargetId() {
+    const page = await getPageForTargetId({ cdpUrl: this.cdpUrl, targetId: this._targetId });
+    const newId = await pageTargetId(page);
+    if (newId !== null && newId !== "") this._targetId = newId;
+    return this._targetId;
   }
   // ── Snapshot ──────────────────────────────────────────────────
   /**
@@ -5213,7 +5436,7 @@ var CrawlPage = class {
     if (opts?.mode === "role") {
       return snapshotRole({
         cdpUrl: this.cdpUrl,
-        targetId: this.targetId,
+        targetId: this._targetId,
         selector: opts.selector,
         frameSelector: opts.frameSelector,
         refsMode: opts.refsMode,
@@ -5232,7 +5455,7 @@ var CrawlPage = class {
     }
     return snapshotAi({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       maxChars: opts?.maxChars,
       options: {
         interactive: opts?.interactive,
@@ -5251,7 +5474,7 @@ var CrawlPage = class {
    * @returns Array of accessibility tree nodes
    */
   async ariaSnapshot(opts) {
-    return snapshotAria({ cdpUrl: this.cdpUrl, targetId: this.targetId, limit: opts?.limit });
+    return snapshotAria({ cdpUrl: this.cdpUrl, targetId: this._targetId, limit: opts?.limit });
   }
   // ── Interactions ─────────────────────────────────────────────
   /**
@@ -5271,7 +5494,7 @@ var CrawlPage = class {
   async click(ref, opts) {
     return clickViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       ref,
       doubleClick: opts?.doubleClick,
       button: opts?.button,
@@ -5298,7 +5521,7 @@ var CrawlPage = class {
   async clickBySelector(selector, opts) {
     return clickViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       selector,
       doubleClick: opts?.doubleClick,
       button: opts?.button,
@@ -5327,7 +5550,7 @@ var CrawlPage = class {
   async mouseClick(x, y, opts) {
     return mouseClickViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       x,
       y,
       button: opts?.button,
@@ -5354,7 +5577,7 @@ var CrawlPage = class {
   async pressAndHold(x, y, opts) {
     return pressAndHoldViaCdp({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       x,
       y,
       delay: opts?.delay,
@@ -5378,7 +5601,7 @@ var CrawlPage = class {
   async clickByText(text, opts) {
     return clickByTextViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       text,
       exact: opts?.exact,
       button: opts?.button,
@@ -5405,7 +5628,7 @@ var CrawlPage = class {
   async clickByRole(role, name, opts) {
     return clickByRoleViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       role,
       name,
       index: opts?.index,
@@ -5434,7 +5657,7 @@ var CrawlPage = class {
   async type(ref, text, opts) {
     return typeViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       ref,
       text,
       submit: opts?.submit,
@@ -5451,7 +5674,7 @@ var CrawlPage = class {
   async hover(ref, opts) {
     return hoverViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       ref,
       timeoutMs: opts?.timeoutMs
     });
@@ -5471,7 +5694,7 @@ var CrawlPage = class {
   async select(ref, ...values) {
     return selectOptionViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       ref,
       values
     });
@@ -5486,7 +5709,7 @@ var CrawlPage = class {
   async drag(startRef, endRef, opts) {
     return dragViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       startRef,
       endRef,
       timeoutMs: opts?.timeoutMs
@@ -5511,7 +5734,7 @@ var CrawlPage = class {
   async fill(fields) {
     return fillFormViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       fields
     });
   }
@@ -5524,7 +5747,7 @@ var CrawlPage = class {
   async scrollIntoView(ref, opts) {
     return scrollIntoViewViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       ref,
       timeoutMs: opts?.timeoutMs
     });
@@ -5537,7 +5760,7 @@ var CrawlPage = class {
   async highlight(ref) {
     return highlightViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       ref
     });
   }
@@ -5550,7 +5773,7 @@ var CrawlPage = class {
   async uploadFile(ref, paths) {
     return setInputFilesViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       ref,
       paths
     });
@@ -5573,7 +5796,7 @@ var CrawlPage = class {
   async armDialog(opts) {
     return armDialogViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       accept: opts.accept,
       promptText: opts.promptText,
       timeoutMs: opts.timeoutMs
@@ -5617,7 +5840,7 @@ var CrawlPage = class {
   async onDialog(handler) {
     return setDialogHandler({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       handler: handler ?? void 0
     });
   }
@@ -5639,7 +5862,7 @@ var CrawlPage = class {
   async armFileUpload(paths, opts) {
     return armFileUploadViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       paths,
       timeoutMs: opts?.timeoutMs
     });
@@ -5654,7 +5877,7 @@ var CrawlPage = class {
   async batch(actions, opts) {
     return batchViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       actions,
       stopOnError: opts?.stopOnError,
       evaluateEnabled: opts?.evaluateEnabled
@@ -5679,7 +5902,7 @@ var CrawlPage = class {
   async press(key, opts) {
     return pressKeyViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       key,
       delayMs: opts?.delayMs
     });
@@ -5689,14 +5912,14 @@ var CrawlPage = class {
    * Get the current URL of the page.
    */
   async url() {
-    const page = await getPageForTargetId({ cdpUrl: this.cdpUrl, targetId: this.targetId });
+    const page = await getPageForTargetId({ cdpUrl: this.cdpUrl, targetId: this._targetId });
     return page.url();
   }
   /**
    * Get the page title.
    */
   async title() {
-    const page = await getPageForTargetId({ cdpUrl: this.cdpUrl, targetId: this.targetId });
+    const page = await getPageForTargetId({ cdpUrl: this.cdpUrl, targetId: this._targetId });
     return page.title();
   }
   /**
@@ -5709,7 +5932,7 @@ var CrawlPage = class {
   async goto(url, opts) {
     return navigateViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       url,
       timeoutMs: opts?.timeoutMs,
       ssrfPolicy: this.ssrfPolicy
@@ -5721,7 +5944,7 @@ var CrawlPage = class {
    * @param opts - Timeout options
    */
   async reload(opts) {
-    const page = await getPageForTargetId({ cdpUrl: this.cdpUrl, targetId: this.targetId });
+    const page = await getPageForTargetId({ cdpUrl: this.cdpUrl, targetId: this._targetId });
     ensurePageState(page);
     await page.reload({ timeout: normalizeTimeoutMs(opts?.timeoutMs, 2e4) });
   }
@@ -5731,7 +5954,7 @@ var CrawlPage = class {
    * @param opts - Timeout options
    */
   async goBack(opts) {
-    const page = await getPageForTargetId({ cdpUrl: this.cdpUrl, targetId: this.targetId });
+    const page = await getPageForTargetId({ cdpUrl: this.cdpUrl, targetId: this._targetId });
     ensurePageState(page);
     await page.goBack({ timeout: normalizeTimeoutMs(opts?.timeoutMs, 2e4) });
   }
@@ -5741,7 +5964,7 @@ var CrawlPage = class {
    * @param opts - Timeout options
    */
   async goForward(opts) {
-    const page = await getPageForTargetId({ cdpUrl: this.cdpUrl, targetId: this.targetId });
+    const page = await getPageForTargetId({ cdpUrl: this.cdpUrl, targetId: this._targetId });
     ensurePageState(page);
     await page.goForward({ timeout: normalizeTimeoutMs(opts?.timeoutMs, 2e4) });
   }
@@ -5764,7 +5987,7 @@ var CrawlPage = class {
   async waitFor(opts) {
     return waitForViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       ...opts
     });
   }
@@ -5789,7 +6012,7 @@ var CrawlPage = class {
   async evaluate(fn, opts) {
     return evaluateViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       fn,
       ref: opts?.ref,
       timeoutMs: opts?.timeoutMs,
@@ -5816,7 +6039,7 @@ var CrawlPage = class {
   async evaluateInAllFrames(fn) {
     return evaluateInAllFramesViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       fn
     });
   }
@@ -5837,7 +6060,7 @@ var CrawlPage = class {
   async screenshot(opts) {
     const result = await takeScreenshotViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       fullPage: opts?.fullPage,
       ref: opts?.ref,
       element: opts?.element,
@@ -5853,7 +6076,7 @@ var CrawlPage = class {
    * @returns PDF document as a Buffer
    */
   async pdf() {
-    const result = await pdfViaPlaywright({ cdpUrl: this.cdpUrl, targetId: this.targetId });
+    const result = await pdfViaPlaywright({ cdpUrl: this.cdpUrl, targetId: this._targetId });
     return result.buffer;
   }
   /**
@@ -5874,7 +6097,7 @@ var CrawlPage = class {
   async screenshotWithLabels(refs, opts) {
     return screenshotWithLabelsViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       refs,
       maxLabels: opts?.maxLabels,
       type: opts?.type
@@ -5891,7 +6114,7 @@ var CrawlPage = class {
   async traceStart(opts) {
     return traceStartViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       screenshots: opts?.screenshots,
       snapshots: opts?.snapshots,
       sources: opts?.sources
@@ -5906,7 +6129,7 @@ var CrawlPage = class {
   async traceStop(path2, opts) {
     return traceStopViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       path: path2,
       allowedOutputRoots: opts?.allowedOutputRoots
     });
@@ -5927,7 +6150,7 @@ var CrawlPage = class {
   async responseBody(url, opts) {
     return responseBodyViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       url,
       timeoutMs: opts?.timeoutMs,
       maxChars: opts?.maxChars
@@ -5955,7 +6178,7 @@ var CrawlPage = class {
   async waitForRequest(url, opts) {
     return waitForRequestViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       url,
       method: opts?.method,
       timeoutMs: opts?.timeoutMs,
@@ -5973,7 +6196,7 @@ var CrawlPage = class {
   async consoleLogs(opts) {
     return getConsoleMessagesViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       level: opts?.level,
       clear: opts?.clear
     });
@@ -5987,7 +6210,7 @@ var CrawlPage = class {
   async pageErrors(opts) {
     const result = await getPageErrorsViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       clear: opts?.clear
     });
     return result.errors;
@@ -6008,7 +6231,7 @@ var CrawlPage = class {
   async networkRequests(opts) {
     const result = await getNetworkRequestsViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       filter: opts?.filter,
       clear: opts?.clear
     });
@@ -6024,7 +6247,7 @@ var CrawlPage = class {
   async resize(width, height) {
     return resizeViewportViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       width,
       height
     });
@@ -6036,7 +6259,7 @@ var CrawlPage = class {
    * @returns Array of cookie objects
    */
   async cookies() {
-    const result = await cookiesGetViaPlaywright({ cdpUrl: this.cdpUrl, targetId: this.targetId });
+    const result = await cookiesGetViaPlaywright({ cdpUrl: this.cdpUrl, targetId: this._targetId });
     return result.cookies;
   }
   /**
@@ -6054,11 +6277,11 @@ var CrawlPage = class {
    * ```
    */
   async setCookie(cookie) {
-    return cookiesSetViaPlaywright({ cdpUrl: this.cdpUrl, targetId: this.targetId, cookie });
+    return cookiesSetViaPlaywright({ cdpUrl: this.cdpUrl, targetId: this._targetId, cookie });
   }
   /** Clear all cookies in the browser context. */
   async clearCookies() {
-    return cookiesClearViaPlaywright({ cdpUrl: this.cdpUrl, targetId: this.targetId });
+    return cookiesClearViaPlaywright({ cdpUrl: this.cdpUrl, targetId: this._targetId });
   }
   /**
    * Get values from localStorage or sessionStorage.
@@ -6070,7 +6293,7 @@ var CrawlPage = class {
   async storageGet(kind, key) {
     const result = await storageGetViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       kind,
       key
     });
@@ -6086,7 +6309,7 @@ var CrawlPage = class {
   async storageSet(kind, key, value) {
     return storageSetViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       kind,
       key,
       value
@@ -6100,7 +6323,7 @@ var CrawlPage = class {
   async storageClear(kind) {
     return storageClearViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       kind
     });
   }
@@ -6122,7 +6345,7 @@ var CrawlPage = class {
   async download(ref, path2, opts) {
     return downloadViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       ref,
       path: path2,
       timeoutMs: opts?.timeoutMs,
@@ -6140,7 +6363,7 @@ var CrawlPage = class {
   async waitForDownload(opts) {
     return waitForDownloadViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       path: opts?.path,
       timeoutMs: opts?.timeoutMs,
       allowedOutputRoots: opts?.allowedOutputRoots
@@ -6155,7 +6378,7 @@ var CrawlPage = class {
   async setOffline(offline) {
     return setOfflineViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       offline
     });
   }
@@ -6172,7 +6395,7 @@ var CrawlPage = class {
   async setExtraHeaders(headers) {
     return setExtraHTTPHeadersViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       headers
     });
   }
@@ -6184,7 +6407,7 @@ var CrawlPage = class {
   async setHttpCredentials(opts) {
     return setHttpCredentialsViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       username: opts.username,
       password: opts.password,
       clear: opts.clear
@@ -6204,7 +6427,7 @@ var CrawlPage = class {
   async setGeolocation(opts) {
     return setGeolocationViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       latitude: opts.latitude,
       longitude: opts.longitude,
       accuracy: opts.accuracy,
@@ -6225,7 +6448,7 @@ var CrawlPage = class {
   async emulateMedia(opts) {
     return emulateMediaViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       colorScheme: opts.colorScheme
     });
   }
@@ -6237,7 +6460,7 @@ var CrawlPage = class {
   async setLocale(locale) {
     return setLocaleViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       locale
     });
   }
@@ -6249,7 +6472,7 @@ var CrawlPage = class {
   async setTimezone(timezoneId) {
     return setTimezoneViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       timezoneId
     });
   }
@@ -6266,7 +6489,7 @@ var CrawlPage = class {
   async setDevice(name) {
     return setDeviceViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       name
     });
   }
@@ -6287,7 +6510,7 @@ var CrawlPage = class {
    * ```
    */
   async detectChallenge() {
-    return detectChallengeViaPlaywright({ cdpUrl: this.cdpUrl, targetId: this.targetId });
+    return detectChallengeViaPlaywright({ cdpUrl: this.cdpUrl, targetId: this._targetId });
   }
   /**
    * Wait for an anti-bot challenge to resolve on its own.
@@ -6312,7 +6535,7 @@ var CrawlPage = class {
   async waitForChallenge(opts) {
     return waitForChallengeViaPlaywright({
       cdpUrl: this.cdpUrl,
-      targetId: this.targetId,
+      targetId: this._targetId,
       timeoutMs: opts?.timeoutMs,
       pollMs: opts?.pollMs
     });
@@ -6349,8 +6572,24 @@ var CrawlPage = class {
    */
   async isAuthenticated(rules) {
     if (!rules.length) return { authenticated: true, checks: [] };
-    const page = await getRestoredPageForTarget({ cdpUrl: this.cdpUrl, targetId: this.targetId });
+    const page = await getRestoredPageForTarget({ cdpUrl: this.cdpUrl, targetId: this._targetId });
     const checks = [];
+    const needsBodyText = rules.some((r) => r.text !== void 0 || r.textGone !== void 0);
+    let bodyText = null;
+    if (needsBodyText) {
+      try {
+        const raw = await evaluateViaPlaywright({
+          cdpUrl: this.cdpUrl,
+          targetId: this._targetId,
+          fn: '() => { const b = document.body; return b ? b.innerText : ""; }'
+        });
+        bodyText = typeof raw === "string" ? raw : null;
+      } catch (err) {
+        console.warn(
+          `[browserclaw] isAuthenticated body text fetch failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
     for (const rule of rules) {
       if (rule.url !== void 0) {
         const currentUrl = page.url();
@@ -6383,19 +6622,6 @@ var CrawlPage = class {
         }
       }
       if (rule.text !== void 0 || rule.textGone !== void 0) {
-        let bodyText = null;
-        try {
-          const raw = await evaluateViaPlaywright({
-            cdpUrl: this.cdpUrl,
-            targetId: this.targetId,
-            fn: '() => { const b = document.body; return b ? b.innerText : ""; }'
-          });
-          bodyText = typeof raw === "string" ? raw : null;
-        } catch (err) {
-          console.warn(
-            `[browserclaw] isAuthenticated body text fetch failed: ${err instanceof Error ? err.message : String(err)}`
-          );
-        }
         if (rule.text !== void 0) {
           if (bodyText === null) {
             checks.push({ rule: "text", passed: false, detail: `"${rule.text}" error during evaluation` });
@@ -6425,7 +6651,7 @@ var CrawlPage = class {
         try {
           const result = await evaluateViaPlaywright({
             cdpUrl: this.cdpUrl,
-            targetId: this.targetId,
+            targetId: this._targetId,
             fn: rule.fn
           });
           const passed = result !== null && result !== void 0 && result !== false && result !== 0 && result !== "";
@@ -6474,7 +6700,7 @@ var CrawlPage = class {
    * ```
    */
   async playwrightPage() {
-    return getRestoredPageForTarget({ cdpUrl: this.cdpUrl, targetId: this.targetId });
+    return getRestoredPageForTarget({ cdpUrl: this.cdpUrl, targetId: this._targetId });
   }
   /**
    * Create a Playwright `Locator` for a CSS selector on this page.
@@ -6497,7 +6723,7 @@ var CrawlPage = class {
    * ```
    */
   async locator(selector) {
-    const pwPage = await getRestoredPageForTarget({ cdpUrl: this.cdpUrl, targetId: this.targetId });
+    const pwPage = await getRestoredPageForTarget({ cdpUrl: this.cdpUrl, targetId: this._targetId });
     return pwPage.locator(selector);
   }
 };
@@ -6541,21 +6767,27 @@ var BrowserClaw = class _BrowserClaw {
   static async launch(opts = {}) {
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const chrome = await launchChrome(opts);
-    const cdpUrl = `http://127.0.0.1:${String(chrome.cdpPort)}`;
-    const ssrfPolicy = opts.allowInternal === true ? { ...opts.ssrfPolicy, dangerouslyAllowPrivateNetwork: true } : opts.ssrfPolicy;
-    const telemetry = {
-      launchMs: chrome.launchMs,
-      timestamps: { startedAt, launchedAt: (/* @__PURE__ */ new Date()).toISOString() }
-    };
-    const browser = new _BrowserClaw(cdpUrl, chrome, telemetry, ssrfPolicy, opts.recordVideo);
-    if (opts.url !== void 0 && opts.url !== "") {
-      const page = await browser.currentPage();
-      const navT0 = Date.now();
-      await page.goto(opts.url);
-      telemetry.navMs = Date.now() - navT0;
-      telemetry.timestamps.navigatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      const cdpUrl = `http://127.0.0.1:${String(chrome.cdpPort)}`;
+      const ssrfPolicy = opts.allowInternal === true ? { ...opts.ssrfPolicy, dangerouslyAllowPrivateNetwork: true } : opts.ssrfPolicy;
+      const telemetry = {
+        launchMs: chrome.launchMs,
+        timestamps: { startedAt, launchedAt: (/* @__PURE__ */ new Date()).toISOString() }
+      };
+      const browser = new _BrowserClaw(cdpUrl, chrome, telemetry, ssrfPolicy, opts.recordVideo);
+      if (opts.url !== void 0 && opts.url !== "") {
+        const page = await browser.currentPage();
+        const navT0 = Date.now();
+        await page.goto(opts.url);
+        telemetry.navMs = Date.now() - navT0;
+        telemetry.timestamps.navigatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      return browser;
+    } catch (err) {
+      await stopChrome(chrome).catch(() => {
+      });
+      throw err;
     }
-    return browser;
   }
   /**
    * Connect to an already-running Chrome instance via its CDP endpoint.
@@ -6712,7 +6944,7 @@ var BrowserClaw = class _BrowserClaw {
     if (exitReason !== void 0) this._telemetry.exitReason = exitReason;
     try {
       clearRecordingContext(this.cdpUrl);
-      await disconnectBrowser();
+      await closePlaywrightBrowserConnection({ cdpUrl: this.cdpUrl });
       if (this.chrome) {
         await stopChrome(this.chrome);
         this.chrome = null;