cdp-toolkit 1.0.0 → 1.2.0

package/dist/cli.js

@@ -1,8 +1,256 @@
 #!/usr/bin/env node
 
-// src/tools/pages.ts
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
+// src/leases.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var DEFAULT_LEASE_TTL_MS = 900000;
+function leaseDir() {
+  return process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
+}
+function leaseTtlMs() {
+  const raw = Number(process.env.CDP_LEASE_TTL_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_LEASE_TTL_MS;
+}
+function safeId(id) {
+  return id.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+function leaseFile(backend, targetId) {
+  return join(leaseDir(), `lease-${backend}-${safeId(targetId)}.json`);
+}
+function mintToken(backend, targetId, nonce) {
+  return `${backend}:${targetId}:${nonce}`;
+}
+function tokenParts(token) {
+  if (typeof token !== "string")
+    return;
+  const first = token.indexOf(":");
+  const last = token.lastIndexOf(":");
+  if (first <= 0 || last <= first)
+    return;
+  const backend = token.slice(0, first);
+  if (backend !== "chrome" && backend !== "firefox")
+    return;
+  const targetId = token.slice(first + 1, last);
+  const nonce = token.slice(last + 1);
+  if (!targetId.length || !/^[0-9a-f]{24}$/.test(nonce))
+    return;
+  return { backend, targetId, nonce };
+}
+
+class LeaseConflictError extends Error {
+  targetId;
+  holder;
+  constructor(message, targetId, holder) {
+    super(message);
+    this.targetId = targetId;
+    this.holder = holder;
+    this.name = "LeaseConflictError";
+  }
+}
+async function readLease(backend, targetId) {
+  let raw;
+  try {
+    raw = await readFile(leaseFile(backend, targetId), "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return;
+    throw err;
+  }
+  try {
+    const rec = JSON.parse(raw);
+    if (typeof rec?.nonce === "string" && typeof rec?.pid === "number")
+      return rec;
+  } catch {}
+  return;
+}
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function staleReason(rec, opts) {
+  if (!isPidAlive(rec.pid))
+    return "dead-pid";
+  if (opts.now - rec.lastUsedAt > rec.ttlMs)
+    return "expired";
+  if (opts.liveIds && !opts.liveIds.includes(rec.targetId))
+    return "target-gone";
+  return false;
+}
+async function claimLease(backend, targetId, opts) {
+  const now = opts.now ?? Date.now();
+  await mkdir(leaseDir(), { recursive: true });
+  for (let attempt = 0;attempt < 3; attempt++) {
+    const record = {
+      backend,
+      targetId,
+      nonce: randomBytes(12).toString("hex"),
+      pid: process.pid,
+      label: opts.label,
+      createdAt: now,
+      lastUsedAt: now,
+      ttlMs: opts.ttlMs ?? leaseTtlMs()
+    };
+    try {
+      await writeFile(leaseFile(backend, targetId), JSON.stringify(record), { flag: "wx" });
+      return { token: mintToken(backend, targetId, record.nonce), record };
+    } catch (err) {
+      if (err.code !== "EEXIST")
+        throw err;
+    }
+    const existing = await readLease(backend, targetId);
+    if (!existing)
+      continue;
+    const stale = staleReason(existing, { now, liveIds: opts.liveIds });
+    if (!stale) {
+      throw new LeaseConflictError(`target '${targetId}' is already leased by '${existing.label}' (pid ${existing.pid}); call release_page with that lease's token, or list_leases to inspect it`, targetId, existing.label);
+    }
+    await unlink(leaseFile(backend, targetId)).catch(() => {
+      return;
+    });
+  }
+  throw new LeaseConflictError(`target '${targetId}' could not be claimed after 3 attempts: another process is claiming and releasing it concurrently`, targetId);
+}
+async function releaseLease(token) {
+  const parts = tokenParts(token);
+  if (!parts)
+    return { released: false };
+  const rec = await readLease(parts.backend, parts.targetId);
+  if (!rec || rec.nonce !== parts.nonce)
+    return { released: false };
+  await unlink(leaseFile(parts.backend, parts.targetId)).catch(() => {
+    return;
+  });
+  return { released: true };
+}
+async function releaseLeaseFor(backend, targetId) {
+  if (!await readLease(backend, targetId))
+    return { released: false };
+  await unlink(leaseFile(backend, targetId)).catch(() => {
+    return;
+  });
+  return { released: true };
+}
+var leaseScope = new AsyncLocalStorage;
+function withLeaseScope(lease, fn) {
+  return leaseScope.run(lease, fn);
+}
+function currentLease() {
+  return leaseScope.getStore();
+}
+function leaseFromArgs(args) {
+  if (!args || typeof args !== "object")
+    return;
+  const lease = args.lease;
+  return typeof lease === "string" && lease.length > 0 ? lease : undefined;
+}
+async function touchLease(rec, now = Date.now()) {
+  const current = await readLease(rec.backend, rec.targetId).catch(() => {
+    return;
+  });
+  if (!current || current.nonce !== rec.nonce)
+    return;
+  await writeFile(leaseFile(current.backend, current.targetId), JSON.stringify({ ...current, lastUsedAt: now }), "utf8").catch(() => {
+    return;
+  });
+}
+function describeTarget(targetId, ctx) {
+  const url = ctx.url ? ` (url ${ctx.url})` : ctx.title ? ` (title ${JSON.stringify(ctx.title)})` : "";
+  return `target '${targetId}'${url}`;
+}
+async function assertLeaseOk(backend, targetId, ctx = {}) {
+  const token = ctx.lease ?? currentLease();
+  const now = ctx.now ?? Date.now();
+  const rec = await readLease(backend, targetId);
+  const held = rec && !staleReason(rec, { now, liveIds: ctx.liveIds }) ? rec : undefined;
+  const where = describeTarget(targetId, ctx);
+  if (token === undefined) {
+    if (!held)
+      return;
+    throw new LeaseConflictError(`${where} is leased by '${held.label}' (pid ${held.pid}). Pass that lease's token as the 'lease' argument, or call release_page to free it. list_leases shows every active lease.`, targetId, held.label);
+  }
+  const parts = tokenParts(token);
+  if (!parts) {
+    throw new LeaseConflictError(`malformed lease token for ${where}. Pass back the token claim_page returned, never a constructed one.`, targetId);
+  }
+  if (parts.backend !== backend || parts.targetId !== targetId) {
+    if (!held)
+      return;
+    throw new LeaseConflictError(`the lease token you passed is for ${parts.backend} target '${parts.targetId}', not ${where}, which is leased by '${held.label}'. Resolve the tab you actually hold, or claim this one.`, targetId, held.label);
+  }
+  if (!held) {
+    throw new LeaseConflictError(`${where} is not leased any more: the token you passed belongs to a lease that was released or reclaimed. Call claim_page again to take the tab.`, targetId);
+  }
+  if (parts.nonce !== held.nonce) {
+    throw new LeaseConflictError(`${where} was reclaimed and is now leased by '${held.label}' (pid ${held.pid}). Your token was invalidated by that reclamation. Call claim_page again if you still need this tab.`, targetId, held.label);
+  }
+  await touchLease(held, now);
+}
+var LEASE_FILE_RE = /^lease-(chrome|firefox)-(.+)\.json$/;
+async function listLeases(opts = {}) {
+  const now = opts.now ?? Date.now();
+  let names = [];
+  try {
+    names = await readdir(leaseDir());
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return [];
+    throw err;
+  }
+  const out = [];
+  for (const name of names) {
+    const parts = LEASE_FILE_RE.exec(name);
+    if (!parts)
+      continue;
+    const fromName = {
+      backend: parts[1],
+      targetId: parts[2],
+      label: "",
+      pid: 0,
+      createdAt: 0,
+      lastUsedAt: 0,
+      ttlMs: 0,
+      pidAlive: false,
+      stale: false
+    };
+    let rec;
+    try {
+      rec = JSON.parse(await readFile(join(leaseDir(), name), "utf8"));
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        continue;
+      out.push({ ...fromName, unreadable: code ?? "unparseable" });
+      continue;
+    }
+    if (typeof rec?.nonce !== "string" || typeof rec?.pid !== "number") {
+      out.push({ ...fromName, unreadable: "unparseable" });
+      continue;
+    }
+    out.push({
+      backend: rec.backend,
+      targetId: rec.targetId,
+      label: rec.label,
+      pid: rec.pid,
+      createdAt: rec.createdAt,
+      lastUsedAt: rec.lastUsedAt,
+      ttlMs: rec.ttlMs,
+      pidAlive: isPidAlive(rec.pid),
+      stale: staleReason(rec, {
+        now,
+        liveIds: opts.liveBackend === undefined || opts.liveBackend === rec.backend ? opts.liveIds : undefined
+      })
+    });
+  }
+  return out;
+}
 
 // src/client.ts
 var BASE = process.env.CDP_BASE ?? "http://127.0.0.1:9222";
@@ -157,8 +405,13 @@ async function browserWsUrl() {
   const v = await httpJson("/json/version");
   return v.webSocketDebuggerUrl;
 }
-async function resolveTarget(selector) {
+async function resolveTarget(selector, opts = {}) {
   const targets = await listTargets();
+  const hit = pickTarget(targets, selector);
+  await assertLeaseOk("chrome", hit.id, { lease: opts.lease, url: hit.url, title: hit.title });
+  return hit;
+}
+function pickTarget(targets, selector) {
   const pages = targets.filter((t) => t.type === "page");
   if (!selector || selector === "active") {
     if (!pages.length)
@@ -194,7 +447,7 @@ async function openBrowser(opts = {}) {
   return new CdpConnection(await browserWsUrl(), opts).connect();
 }
 async function openPage(selector, opts = {}) {
-  const target = await resolveTarget(selector);
+  const target = await resolveTarget(selector, { lease: opts.lease });
   const conn = await new CdpConnection(target.webSocketDebuggerUrl, opts).connect();
   return { conn, target };
 }
@@ -207,191 +460,6 @@ async function withPage(selector, fn, opts = {}) {
   }
 }
 
-// src/tools/pages.ts
-var STATE_DIR = process.env.CDP_STATE_DIR ?? "/tmp/cdp-toolkit";
-var SELECTED_FILE = `${STATE_DIR}/selected`;
-function toPageInfo(t) {
-  return { id: t.id, url: t.url, title: t.title, type: t.type };
-}
-async function listPages(args = {}) {
-  const targets = await listTargets();
-  const filtered = args.all ? targets : targets.filter((t) => t.type === "page");
-  const pages = filtered.map(toPageInfo);
-  return { pages, count: pages.length };
-}
-async function newPage(args = {}) {
-  const url = args.url ?? "about:blank";
-  const conn = await openBrowser();
-  try {
-    const { targetId } = await conn.send("Target.createTarget", { url });
-    if (!targetId)
-      throw new CdpError("Target.createTarget returned no targetId");
-    return { targetId, url };
-  } finally {
-    conn.close();
-  }
-}
-async function closePage(args) {
-  if (args.target === undefined || args.target === "") {
-    throw new CdpError("close_page requires an explicit target; refusing to guess which page to close");
-  }
-  const target = await resolveTarget(args.target);
-  const conn = await openBrowser();
-  try {
-    const res = await conn.send("Target.closeTarget", { targetId: target.id });
-    return { closed: target.id, success: res.success ?? true };
-  } finally {
-    conn.close();
-  }
-}
-async function selectPage(args) {
-  if (args.target === undefined || args.target === "") {
-    throw new CdpError("select_page requires an explicit target");
-  }
-  const target = await resolveTarget(args.target);
-  const conn = await openBrowser();
-  try {
-    await conn.send("Target.activateTarget", { targetId: target.id });
-  } finally {
-    conn.close();
-  }
-  await mkdir(dirname(SELECTED_FILE), { recursive: true });
-  await writeFile(SELECTED_FILE, target.id, "utf8");
-  return { selected: target.id };
-}
-
-// src/tools/navigation.ts
-async function navigatePage(args) {
-  const reload = args.reload === true;
-  if (!reload && (!args.url || typeof args.url !== "string")) {
-    throw new CdpError("navigate_page: 'url' is required (or pass reload:true to reload the current page)");
-  }
-  const waitUntil = args.waitUntil ?? "load";
-  return withPage(args.target, async (conn) => {
-    await conn.send("Page.enable");
-    const milestoneMethod = waitUntil === "load" ? "Page.loadEventFired" : "Page.domContentEventFired";
-    const milestone = conn.waitFor(milestoneMethod, undefined, args.timeoutMs).then(() => waitUntil).catch(() => {
-      return;
-    });
-    const stopped = conn.waitFor("Page.frameStoppedLoading", undefined, args.timeoutMs).then(() => "frameStoppedLoading").catch(() => {
-      return;
-    });
-    let resolvedUrl;
-    let frameId;
-    if (reload) {
-      await conn.send("Page.reload", { ignoreCache: args.ignoreCache === true }, args.timeoutMs ? { timeoutMs: args.timeoutMs } : {});
-      const tree = await conn.send("Page.getFrameTree").catch(() => {
-        return;
-      });
-      frameId = tree?.frameTree?.frame?.id ?? "";
-      resolvedUrl = tree?.frameTree?.frame?.url ?? args.url ?? "";
-    } else {
-      const nav = await conn.send("Page.navigate", { url: args.url }, args.timeoutMs ? { timeoutMs: args.timeoutMs } : {});
-      if (nav.errorText) {
-        throw new CdpError(`navigate_page: ${nav.errorText} (${args.url})`);
-      }
-      frameId = nav.frameId;
-      resolvedUrl = args.url;
-    }
-    const settled = await Promise.race([milestone, stopped]);
-    const waitedFor = settled ?? "navigate-only";
-    return reload ? { url: resolvedUrl, frameId, reloaded: true, waitedFor } : { url: resolvedUrl, frameId, waitedFor };
-  }, args.timeoutMs ? { timeoutMs: args.timeoutMs } : {});
-}
-var DEFAULT_WAIT_TIMEOUT_MS = 15000;
-var DEFAULT_POLL_MS = 250;
-async function waitForText(args) {
-  if (typeof args.text !== "string" || args.text.length === 0) {
-    throw new CdpError("wait_for: 'text' is required");
-  }
-  const timeoutMs = args.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
-  const pollMs = args.pollMs ?? DEFAULT_POLL_MS;
-  const start = Date.now();
-  return withPage(args.target, async (conn, _target) => {
-    await conn.send("Runtime.enable");
-    const expr = `(() => { const b = document.body; return !!b && typeof b.innerText === 'string' && b.innerText.includes(${JSON.stringify(args.text)}); })()`;
-    for (;; ) {
-      const { result } = await conn.send("Runtime.evaluate", {
-        expression: expr,
-        returnByValue: true
-      });
-      if (result?.value === true) {
-        return { found: true, waitedMs: Date.now() - start };
-      }
-      if (Date.now() - start >= timeoutMs) {
-        throw new CdpError(`wait_for: text not found within ${timeoutMs}ms: ${JSON.stringify(args.text)}`);
-      }
-      await delay(Math.min(pollMs, Math.max(0, timeoutMs - (Date.now() - start))));
-    }
-  }, { timeoutMs: Math.max(timeoutMs, DEFAULT_WAIT_TIMEOUT_MS) });
-}
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/tools/evaluate.ts
-function exceptionMessage(details) {
-  const ex = details.exception;
-  const fromObject = ex?.description ?? (typeof ex?.value === "string" ? ex.value : ex?.value !== undefined ? JSON.stringify(ex.value) : undefined);
-  return fromObject ?? details.text ?? "evaluation threw";
-}
-function unwrap(obj) {
-  if (Object.prototype.hasOwnProperty.call(obj, "value"))
-    return obj.value;
-  if (obj.unserializableValue !== undefined)
-    return obj.unserializableValue;
-  if (obj.type === "undefined")
-    return;
-  return obj.description ?? null;
-}
-async function evaluateExpression(conn, expression, awaitPromise) {
-  const res = await conn.send("Runtime.evaluate", {
-    expression,
-    returnByValue: true,
-    awaitPromise,
-    replMode: false,
-    silent: false
-  });
-  if (res.exceptionDetails)
-    throw new CdpError(exceptionMessage(res.exceptionDetails));
-  return unwrap(res.result);
-}
-async function evaluateFunction(conn, expression, awaitPromise, args) {
-  const globalObj = await conn.send("Runtime.evaluate", {
-    expression: "globalThis",
-    returnByValue: false
-  });
-  const objectId = globalObj.result.objectId;
-  if (!objectId)
-    throw new CdpError("could not resolve global object for function call");
-  const res = await conn.send("Runtime.callFunctionOn", {
-    objectId,
-    functionDeclaration: expression,
-    arguments: args.map((value) => ({ value })),
-    returnByValue: true,
-    awaitPromise,
-    silent: false
-  });
-  if (res.exceptionDetails)
-    throw new CdpError(exceptionMessage(res.exceptionDetails));
-  return unwrap(res.result);
-}
-async function evaluateScript(args) {
-  const { expression } = args;
-  if (typeof expression !== "string" || expression.length === 0) {
-    throw new CdpError("evaluateScript: 'expression' must be a non-empty string");
-  }
-  const awaitPromise = args.awaitPromise ?? true;
-  const callArgs = args.args;
-  return withPage(args.target, async (conn) => {
-    await conn.send("Runtime.enable");
-    if (callArgs && callArgs.length > 0) {
-      return evaluateFunction(conn, expression, awaitPromise, callArgs);
-    }
-    return evaluateExpression(conn, expression, awaitPromise);
-  });
-}
-
 // src/tools/snapshot.ts
 var INTERACTIVE_ROLES = new Set([
   "button",
@@ -414,92 +482,6 @@ var INTERACTIVE_ROLES = new Set([
   "MenuItem",
   "Button"
 ]);
-function axString(v) {
-  if (!v)
-    return;
-  const raw = v.value;
-  if (raw === undefined || raw === null)
-    return;
-  const s = String(raw).trim();
-  return s.length ? s : undefined;
-}
-function propValue(node, name) {
-  const p = node.properties?.find((x) => x.name === name);
-  return axString(p?.value);
-}
-function isInteractive(role) {
-  if (!role)
-    return false;
-  return INTERACTIVE_ROLES.has(role) || INTERACTIVE_ROLES.has(role.toLowerCase());
-}
-function formatNode(node, interactiveOnly) {
-  const role = axString(node.role);
-  const name = axString(node.name);
-  const uid = node.backendDOMNodeId;
-  if (uid === undefined)
-    return;
-  if (interactiveOnly && !isInteractive(role))
-    return;
-  if (!interactiveOnly && !role && !name)
-    return;
-  const extras = [];
-  const value = axString(node.value);
-  if (value)
-    extras.push(`value=${JSON.stringify(value)}`);
-  const checked = propValue(node, "checked");
-  if (checked && checked !== "false")
-    extras.push(`checked=${checked}`);
-  const expanded = propValue(node, "expanded");
-  if (expanded)
-    extras.push(`expanded=${expanded}`);
-  const disabled = propValue(node, "disabled");
-  if (disabled === "true")
-    extras.push("disabled");
-  const url = propValue(node, "url");
-  if (url)
-    extras.push(`url=${url}`);
-  const focused = propValue(node, "focused");
-  if (focused === "true")
-    extras.push("focused");
-  const label = name ? ` ${JSON.stringify(name)}` : "";
-  const extra = extras.length ? ` [${extras.join(" ")}]` : "";
-  return `[${uid}] ${role ?? "generic"}${label}${extra}`;
-}
-async function takeSnapshot(args = {}) {
-  const interactiveOnly = args.interactiveOnly ?? false;
-  return withPage(args.target, async (conn, target) => {
-    await conn.send("Accessibility.enable");
-    const { nodes } = await conn.send("Accessibility.getFullAXTree");
-    const byId = new Map;
-    for (const n of nodes)
-      byId.set(n.nodeId, n);
-    const roots = nodes.filter((n) => !n.parentId || !byId.has(n.parentId));
-    const lines = [];
-    let nodeCount = 0;
-    const walk = (node, depth) => {
-      const line = node.ignored ? undefined : formatNode(node, interactiveOnly);
-      if (line !== undefined) {
-        const indent = interactiveOnly ? "" : "  ".repeat(depth);
-        lines.push(`${indent}${line}`);
-        nodeCount++;
-      }
-      const childDepth = line !== undefined && !interactiveOnly ? depth + 1 : depth;
-      for (const childId of node.childIds ?? []) {
-        const child = byId.get(childId);
-        if (child)
-          walk(child, childDepth);
-      }
-    };
-    for (const root of roots)
-      walk(root, 0);
-    return {
-      snapshot: lines.join(`
-`),
-      target: { id: target.id, url: target.url, title: target.title },
-      nodeCount
-    };
-  });
-}
 async function resolveUid(conn, uid) {
   const { object } = await conn.send("DOM.resolveNode", {
     backendNodeId: uid
@@ -510,149 +492,236 @@ async function resolveUid(conn, uid) {
   return { objectId: object.objectId };
 }
 
-// src/tools/input.ts
-async function resolveElement(conn, t) {
-  const hasUid = t.uid !== undefined && t.uid !== null;
-  const hasSelector = typeof t.selector === "string" && t.selector.length > 0;
-  if (hasUid === hasSelector) {
-    throw new CdpError("provide exactly one of { uid } or { selector }");
-  }
-  if (hasUid) {
-    return resolveUid(conn, t.uid);
-  }
-  const { result, exceptionDetails } = await conn.send("Runtime.evaluate", {
-    expression: `document.querySelector(${JSON.stringify(t.selector)})`,
-    returnByValue: false
-  });
-  if (exceptionDetails) {
-    throw new CdpError(`selector '${t.selector}' evaluation failed: ${exceptionDetails.text ?? "error"}`);
-  }
-  if (!result.objectId || result.subtype === "null") {
-    throw new CdpError(`selector '${t.selector}' matched no element`);
-  }
-  return { objectId: result.objectId };
+// src/tools/network_mock.ts
+function escapeRegExpChar(ch) {
+  return /[.*+?^${}()|[\]\\]/.test(ch) ? `\\${ch}` : ch;
 }
-async function centerOf(conn, objectId) {
-  const { result, exceptionDetails } = await conn.send("Runtime.callFunctionOn", {
-    objectId,
-    functionDeclaration: "function(){this.scrollIntoView({block:'center',inline:'center'});const r=this.getBoundingClientRect();if(r.width===0&&r.height===0)return null;return {x:r.left+r.width/2,y:r.top+r.height/2};}",
-    returnByValue: true
-  });
-  if (exceptionDetails) {
-    throw new CdpError(`could not measure element: ${exceptionDetails.text ?? "error"}`);
-  }
-  if (!result.value) {
-    throw new CdpError("element has zero size / is not visible; cannot compute a click point");
+function globToRegExp(pattern) {
+  let re = "";
+  for (let i = 0;i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "\\") {
+      const next = pattern[i + 1];
+      if (next !== undefined) {
+        re += escapeRegExpChar(next);
+        i++;
+      } else {
+        re += "\\\\";
+      }
+    } else if (ch === "*") {
+      re += ".*";
+    } else if (ch === "?") {
+      re += ".";
+    } else {
+      re += escapeRegExpChar(ch);
+    }
   }
-  return result.value;
-}
-async function focusElement(conn, objectId) {
-  await conn.send("Runtime.callFunctionOn", {
-    objectId,
-    functionDeclaration: "function(){this.focus&&this.focus();}",
-    returnByValue: true
-  });
-}
-async function click(args) {
-  const button = args.button ?? "left";
-  const clickCount = args.clickCount ?? 1;
-  return withPage(args.target, async (conn) => {
-    const { objectId } = await resolveElement(conn, args);
-    const { x, y } = await centerOf(conn, objectId);
-    await conn.send("Input.dispatchMouseEvent", { type: "mouseMoved", x, y });
-    await conn.send("Input.dispatchMouseEvent", { type: "mousePressed", x, y, button, clickCount });
-    await conn.send("Input.dispatchMouseEvent", { type: "mouseReleased", x, y, button, clickCount });
-    return { clicked: true, x, y };
-  });
+  return new RegExp(`^${re}$`);
 }
-async function hover(args) {
-  return withPage(args.target, async (conn) => {
-    const { objectId } = await resolveElement(conn, args);
-    const { x, y } = await centerOf(conn, objectId);
-    await conn.send("Input.dispatchMouseEvent", { type: "mouseMoved", x, y });
-    return { hovered: true, x, y };
-  });
+function urlMatches(pattern, url) {
+  return globToRegExp(pattern).test(url);
 }
-async function drag(args) {
-  if (!args.from || !args.to)
-    throw new CdpError("drag requires { from } and { to }");
-  return withPage(args.target, async (conn) => {
-    const { objectId: srcId } = await resolveElement(conn, args.from);
-    const from = await centerOf(conn, srcId);
-    const { objectId: dstId } = await resolveElement(conn, args.to);
-    const to = await centerOf(conn, dstId);
-    await conn.send("Input.dispatchMouseEvent", { type: "mouseMoved", x: from.x, y: from.y });
-    await conn.send("Input.dispatchMouseEvent", {
-      type: "mousePressed",
-      x: from.x,
-      y: from.y,
-      button: "left",
-      clickCount: 1
-    });
-    await conn.send("Input.dispatchMouseEvent", {
-      type: "mouseMoved",
-      x: (from.x + to.x) / 2,
-      y: (from.y + to.y) / 2,
-      button: "left"
-    });
-    await conn.send("Input.dispatchMouseEvent", { type: "mouseMoved", x: to.x, y: to.y, button: "left" });
-    await conn.send("Input.dispatchMouseEvent", {
-      type: "mouseReleased",
-      x: to.x,
-      y: to.y,
-      button: "left",
-      clickCount: 1
-    });
-    return { dragged: true, from, to };
-  });
+function selectRule(rules, url, method) {
+  return rules.find((r) => urlMatches(r.urlPattern, url) && (!r.method || r.method.toUpperCase() === method.toUpperCase()));
 }
-async function setValue(conn, objectId, value) {
-  await focusElement(conn, objectId);
-  await conn.send("Runtime.callFunctionOn", {
-    objectId,
-    functionDeclaration: "function(){if('value'in this){this.value='';this.dispatchEvent(new Event('input',{bubbles:true}));}else if(this.isContentEditable){this.textContent='';}}",
-    returnByValue: true
-  });
-  if (value.length) {
-    await conn.send("Input.insertText", { text: value });
+function buildFulfillParams(requestId, rule) {
+  const merged = new Map;
+  merged.set("content-type", { name: "Content-Type", value: rule.contentType ?? "application/json" });
+  for (const [name, value] of Object.entries(rule.headers ?? {})) {
+    merged.set(name.toLowerCase(), { name, value });
   }
+  return {
+    requestId,
+    responseCode: rule.status ?? 200,
+    responseHeaders: [...merged.values()],
+    body: Buffer.from(rule.body ?? "", "utf8").toString("base64")
+  };
 }
-async function fill(args) {
-  if (typeof args.value !== "string")
-    throw new CdpError("fill requires a string { value }");
-  return withPage(args.target, async (conn) => {
-    const { objectId } = await resolveElement(conn, args);
-    await setValue(conn, objectId, args.value);
-    return { filled: true, value: args.value };
-  });
-}
-async function typeText(args) {
-  if (typeof args.text !== "string")
-    throw new CdpError("type_text requires a string { text }");
-  return withPage(args.target, async (conn) => {
-    const { objectId } = await resolveElement(conn, args);
-    await focusElement(conn, objectId);
-    if (args.text.length)
-      await conn.send("Input.insertText", { text: args.text });
-    return { typed: true, text: args.text };
+function effectiveAction(rule, rnd) {
+  if (rule.failRate !== undefined && rule.failRate > 0 && rnd < rule.failRate)
+    return "fail";
+  return rule.action;
+}
+var sessions = new Map;
+function delay(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function registerHandler(session) {
+  session.conn.on("Fetch.requestPaused", (params) => {
+    const p = params;
+    session.chain = session.chain.then(async () => {
+      const rule = selectRule(session.rules, p.request.url, p.request.method);
+      if (!rule) {
+        await session.conn.send("Fetch.continueRequest", { requestId: p.requestId });
+        return;
+      }
+      if (rule.delayMs)
+        await delay(rule.delayMs);
+      const act = effectiveAction(rule, Math.random());
+      if (act === "fulfill") {
+        await session.conn.send("Fetch.fulfillRequest", { ...buildFulfillParams(p.requestId, rule) });
+      } else if (act === "fail") {
+        await session.conn.send("Fetch.failRequest", { requestId: p.requestId, errorReason: rule.errorReason ?? "Failed" });
+      } else {
+        await session.conn.send("Fetch.continueRequest", { requestId: p.requestId });
+      }
+      rule.hits++;
+      session.intercepted.push({ url: p.request.url, method: p.request.method, action: act });
+    }).catch((e) => {
+      if (/closed|connection|Target|Inspected/i.test(String(e)))
+        session.dead = true;
+    });
   });
 }
-async function fillForm(args) {
-  if (!Array.isArray(args.fields) || args.fields.length === 0) {
-    throw new CdpError("fill_form requires a non-empty { fields } array");
+async function mockRequest(args) {
+  if (!args.urlPattern)
+    throw new CdpError("mock_request requires a { urlPattern }");
+  const rule = {
+    urlPattern: args.urlPattern,
+    action: args.action ?? "fulfill",
+    status: args.status,
+    body: args.body,
+    contentType: args.contentType,
+    headers: args.headers,
+    errorReason: args.errorReason,
+    method: args.method,
+    delayMs: args.delayMs,
+    failRate: args.failRate,
+    hits: 0
+  };
+  const resolved = await resolveTarget(args.target);
+  let session = sessions.get(resolved.id);
+  if (session && !session.dead) {
+    const idx = session.rules.findIndex((r) => r.urlPattern === rule.urlPattern && (r.method ?? "") === (rule.method ?? ""));
+    if (idx >= 0)
+      session.rules[idx] = rule;
+    else
+      session.rules.push(rule);
+    await session.conn.send("Fetch.enable", { patterns: session.rules.map((r) => ({ urlPattern: r.urlPattern })) });
+  } else {
+    const { conn, target } = await openPage(resolved.id);
+    session = { conn, target, rules: [rule], intercepted: [], chain: Promise.resolve(), dead: false };
+    registerHandler(session);
+    await conn.send("Fetch.enable", { patterns: [{ urlPattern: rule.urlPattern }] });
+    sessions.set(target.id, session);
   }
-  return withPage(args.target, async (conn) => {
-    let filled = 0;
-    for (const field of args.fields) {
-      if (typeof field.value !== "string") {
-        throw new CdpError("each fill_form field requires a string value");
-      }
-      const { objectId } = await resolveElement(conn, field);
-      await setValue(conn, objectId, field.value);
-      filled++;
+  let reloaded = false;
+  if (args.reload) {
+    await session.conn.send("Page.enable");
+    await session.conn.send("Page.reload", { ignoreCache: true });
+    await delay(800);
+    reloaded = true;
+  }
+  return {
+    target: { id: session.target.id, url: session.target.url, title: session.target.title },
+    pattern: rule.urlPattern,
+    ruleCount: session.rules.length,
+    reloaded
+  };
+}
+async function listMocks(_args = {}) {
+  for (const [id, s] of sessions) {
+    if (s.dead) {
+      try {
+        s.conn.close();
+      } catch {}
+      sessions.delete(id);
+      continue;
     }
-    return { filled, fields: args.fields.length };
-  });
+    try {
+      await s.conn.send("Runtime.evaluate", { expression: "1", returnByValue: true }, { timeoutMs: 3000 });
+    } catch {
+      try {
+        s.conn.close();
+      } catch {}
+      sessions.delete(id);
+    }
+  }
+  const mocks = [...sessions.values()].map((s) => ({
+    target: { id: s.target.id, url: s.target.url, title: s.target.title },
+    rules: s.rules.map((r) => ({ urlPattern: r.urlPattern, action: r.action, method: r.method, hits: r.hits })),
+    hits: s.intercepted.length
+  }));
+  return { count: mocks.length, mocks };
+}
+async function clearMocks(args = {}) {
+  let ids;
+  if (args.all) {
+    ids = [...sessions.keys()];
+  } else {
+    const resolved = await resolveTarget(args.target);
+    ids = sessions.has(resolved.id) ? [resolved.id] : [];
+  }
+  let cleared = 0;
+  for (const id of ids) {
+    const s = sessions.get(id);
+    if (!s)
+      continue;
+    try {
+      await s.conn.send("Fetch.disable");
+    } catch {}
+    try {
+      s.conn.close();
+    } catch {}
+    sessions.delete(id);
+    cleared++;
+  }
+  return { cleared };
+}
+
+// src/driver.ts
+var UID_STAMP_ATTR = "data-cdp-uid";
+var LEGACY_NUMERIC_UID = /^[0-9]+$/;
+var REQUIRED_CAPABILITIES = {
+  performance_start_trace: ["trace.performance"],
+  performance_stop_trace: ["trace.performance"],
+  performance_analyze_insight: ["trace.performance"],
+  performance_trace: ["trace.performance"],
+  take_heapsnapshot: ["heap.snapshot"],
+  lighthouse_audit: ["audit.lighthouse"],
+  mock_request: ["network.intercept"],
+  list_mocks: ["network.intercept"],
+  clear_mocks: ["network.intercept"]
+};
+function isDriverError(e) {
+  return e instanceof Error && typeof e.code === "string";
+}
+
+// src/cdp/driver.ts
+function driverError(code, message, data) {
+  return Object.assign(new Error(message), { code, ...data !== undefined ? { data } : {} });
+}
+function encodeUid(backendNodeId) {
+  return `cdp:${backendNodeId}`;
+}
+function decodeUid(uid) {
+  if (LEGACY_NUMERIC_UID.test(uid))
+    return Number(uid);
+  if (!uid.startsWith("cdp:"))
+    throw driverError("foreign-uid", `uid is not owned by the cdp driver: ${uid}`);
+  const n = Number(uid.slice(4));
+  if (!Number.isSafeInteger(n) || n <= 0)
+    throw driverError("foreign-uid", `malformed cdp uid payload: ${uid}`);
+  return n;
+}
+async function centerOf(conn, objectId) {
+  const fn = "function(){this.scrollIntoView({block:'center',inline:'center'});const r=this.getBoundingClientRect();if(r.width===0&&r.height===0)return null;return {x:r.left+r.width/2,y:r.top+r.height/2};}";
+  const { result, exceptionDetails } = await conn.send("Runtime.callFunctionOn", { objectId, functionDeclaration: fn, returnByValue: true });
+  if (exceptionDetails)
+    throw driverError("page-error", `could not measure element: ${exceptionDetails.text ?? "error"}`);
+  if (!result.value)
+    throw driverError("page-error", "element has zero size / is not visible; cannot compute a click point");
+  return result.value;
+}
+async function focusElement(conn, objectId) {
+  await conn.send("Runtime.callFunctionOn", { objectId, functionDeclaration: "function(){this.focus&&this.focus();}", returnByValue: true });
+}
+async function setValueOnObject(conn, objectId, value) {
+  await focusElement(conn, objectId);
+  const fn = "function(){if('value'in this){this.value='';this.dispatchEvent(new Event('input',{bubbles:true}));}else if(this.isContentEditable){this.textContent='';}}";
+  await conn.send("Runtime.callFunctionOn", { objectId, functionDeclaration: fn, returnByValue: true });
+  if (value.length)
+    await conn.send("Input.insertText", { text: value });
 }
 var NAMED_KEYS = {
   enter: { key: "Enter", code: "Enter", keyCode: 13, text: "\r" },
@@ -676,15 +745,7 @@ var NAMED_KEYS = {
   pageup: { key: "PageUp", code: "PageUp", keyCode: 33 },
   pagedown: { key: "PageDown", code: "PageDown", keyCode: 34 }
 };
-var MODIFIER_BITS = {
-  alt: 1,
-  control: 2,
-  ctrl: 2,
-  meta: 4,
-  cmd: 4,
-  command: 4,
-  shift: 8
-};
+var MODIFIER_BITS = { alt: 1, control: 2, ctrl: 2, meta: 4, cmd: 4, command: 4, shift: 8 };
 function resolveKey(key) {
   const named = NAMED_KEYS[key.toLowerCase()];
   if (named)
@@ -694,225 +755,407 @@ function resolveKey(key) {
     const isLetter = upper >= "A" && upper <= "Z";
     const isDigit = key >= "0" && key <= "9";
     const code = isLetter ? `Key${upper}` : isDigit ? `Digit${key}` : `Key${upper}`;
-    const keyCode = upper.charCodeAt(0);
-    return { key, code, keyCode, text: key };
-  }
-  throw new CdpError(`unknown key '${key}' (use a named key like Enter/Tab/ArrowDown or a single character)`);
-}
-async function pressKey(args) {
-  if (typeof args.key !== "string" || !args.key.length) {
-    throw new CdpError("press_key requires a non-empty { key }");
-  }
-  const spec = resolveKey(args.key);
-  let modBits = 0;
-  const mods = args.modifiers ?? [];
-  for (const m of mods) {
-    const bit = MODIFIER_BITS[m.toLowerCase()];
-    if (bit === undefined)
-      throw new CdpError(`unknown modifier '${m}'`);
-    modBits |= bit;
-  }
-  const suppressText = (modBits & ~MODIFIER_BITS.shift) !== 0;
-  return withPage(args.target, async (conn) => {
-    const down = {
-      type: "keyDown",
-      key: spec.key,
-      code: spec.code,
-      windowsVirtualKeyCode: spec.keyCode,
-      nativeVirtualKeyCode: spec.keyCode,
-      modifiers: modBits
-    };
-    if (spec.text && !suppressText) {
-      down.text = spec.text;
-    }
-    await conn.send("Input.dispatchKeyEvent", down);
-    await conn.send("Input.dispatchKeyEvent", {
-      type: "keyUp",
-      key: spec.key,
-      code: spec.code,
-      windowsVirtualKeyCode: spec.keyCode,
-      nativeVirtualKeyCode: spec.keyCode,
-      modifiers: modBits
-    });
-    return { pressed: spec.key, modifiers: mods };
-  });
+    return { key, code, keyCode: upper.charCodeAt(0), text: key };
+  }
+  throw driverError("page-error", `unknown key '${key}' (use a named key like Enter/Tab/ArrowDown or a single character)`);
 }
-async function uploadFile(args) {
-  const files = Array.isArray(args.files) ? args.files : [args.files];
-  if (!files.length || files.some((f) => typeof f !== "string" || !f.length)) {
-    throw new CdpError("upload_file requires { files } as a non-empty path or array of paths");
+function unwrap(obj) {
+  if (Object.prototype.hasOwnProperty.call(obj, "value"))
+    return obj.value;
+  if (obj.unserializableValue !== undefined)
+    return obj.unserializableValue;
+  return obj.type === "undefined" ? undefined : obj.description ?? null;
+}
+function exceptionMessage(details) {
+  const ex = details.exception;
+  const fromObject = ex?.description ?? (typeof ex?.value === "string" ? ex.value : ex?.value !== undefined ? JSON.stringify(ex.value) : undefined);
+  return fromObject ?? details.text ?? "evaluation threw";
+}
+var INTERACTIVE_ROLES2 = new Set([
+  "button",
+  "link",
+  "textbox",
+  "searchbox",
+  "checkbox",
+  "radio",
+  "combobox",
+  "listbox",
+  "option",
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "tab",
+  "switch",
+  "slider",
+  "spinbutton",
+  "textfield"
+]);
+function axString(v) {
+  if (!v || v.value === undefined || v.value === null)
+    return;
+  const s = String(v.value).trim();
+  return s.length ? s : undefined;
+}
+function propValue(node, name) {
+  return axString(node.properties?.find((p) => p.name === name)?.value);
+}
+function isInteractive(role) {
+  return !!role && (INTERACTIVE_ROLES2.has(role) || INTERACTIVE_ROLES2.has(role.toLowerCase()));
+}
+function axExtras(node) {
+  const extras = {};
+  const value = axString(node.value);
+  if (value)
+    extras.value = value;
+  const checked = propValue(node, "checked");
+  if (checked && checked !== "false")
+    extras.checked = checked;
+  const expanded = propValue(node, "expanded");
+  if (expanded)
+    extras.expanded = expanded;
+  if (propValue(node, "disabled") === "true")
+    extras.disabled = "true";
+  const url = propValue(node, "url");
+  if (url)
+    extras.url = url;
+  if (propValue(node, "focused") === "true")
+    extras.focused = "true";
+  return extras;
+}
+async function resolveElementLocator(conn, loc) {
+  if ("uid" in loc) {
+    return resolveUid(conn, decodeUid(loc.uid)).catch(() => {
+      throw driverError("stale-uid", `uid does not resolve: ${loc.uid}`);
+    });
   }
-  return withPage(args.target, async (conn) => {
-    const { objectId } = await resolveElement(conn, args);
-    await conn.send("DOM.setFileInputFiles", { files, objectId });
-    return { uploaded: files };
+  if ("css" in loc) {
+    const { result, exceptionDetails } = await conn.send("Runtime.evaluate", { expression: `document.querySelector(${JSON.stringify(loc.css)})`, returnByValue: false });
+    if (exceptionDetails)
+      throw driverError("page-error", `css '${loc.css}' evaluation failed: ${exceptionDetails.text ?? "error"}`);
+    if (!result.objectId || result.subtype === "null")
+      throw driverError("no-such-element", `css '${loc.css}' matched no element`);
+    return { objectId: result.objectId };
+  }
+  const backendNodeId = await searchLocate(conn, "xpath" in loc ? loc.xpath : loc.text);
+  return resolveUid(conn, backendNodeId).catch(() => {
+    throw driverError("stale-uid", "text/xpath match no longer resolves");
   });
 }
-
-// src/tools/screenshot.ts
-import { writeFile as writeFile2, mkdir as mkdir2 } from "node:fs/promises";
-import { join } from "node:path";
-var ARTIFACT_DIR = process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
-function shortId(id) {
-  return id.slice(0, 8);
+async function searchLocate(conn, query) {
+  await conn.send("DOM.getDocument", { depth: 0 }).catch(() => {
+    return;
+  });
+  const { searchId, resultCount } = await conn.send("DOM.performSearch", { query });
+  try {
+    if (!resultCount)
+      throw driverError("no-such-element", `locator matched nothing: ${query}`);
+    const { nodeIds } = await conn.send("DOM.getSearchResults", { searchId, fromIndex: 0, toIndex: 1 });
+    const nodeId = nodeIds[0];
+    if (nodeId === undefined)
+      throw driverError("no-such-element", `locator matched nothing: ${query}`);
+    const { node } = await conn.send("DOM.describeNode", { nodeId });
+    return node.backendNodeId;
+  } finally {
+    await conn.send("DOM.discardSearchResults", { searchId }).catch(() => {
+      return;
+    });
+  }
 }
-function stamp() {
-  return new Date(Date.now()).toISOString().replace(/[:.]/g, "-");
+async function backendNodeIdOf(conn, loc) {
+  if ("uid" in loc)
+    return decodeUid(loc.uid);
+  if ("css" in loc) {
+    const { objectId } = await resolveElementLocator(conn, loc);
+    const { node } = await conn.send("DOM.describeNode", { objectId });
+    return node.backendNodeId;
+  }
+  return searchLocate(conn, "xpath" in loc ? loc.xpath : loc.text);
 }
 async function fullPageClip(conn) {
   const m = await conn.send("Page.getLayoutMetrics");
   const size = m.cssContentSize ?? m.contentSize;
   if (!size)
-    throw new CdpError("Page.getLayoutMetrics returned no content size");
-  return { x: 0, y: 0, width: Math.ceil(size.width), height: Math.ceil(size.height), scale: 1 };
-}
-async function elementClip(conn, uid, selector) {
-  let backendNodeId;
-  if (uid != null) {
-    backendNodeId = uid;
-  } else if (selector) {
-    const { root } = await conn.send("DOM.getDocument", { depth: 0 });
-    const { nodeId } = await conn.send("DOM.querySelector", {
-      nodeId: root.nodeId,
-      selector
-    });
-    if (!nodeId)
-      throw new CdpError(`selector matched no element: ${selector}`);
-    const desc = await conn.send("DOM.describeNode", { nodeId });
-    backendNodeId = desc.node.backendNodeId;
-  } else {
-    throw new CdpError("elementClip requires uid or selector");
-  }
-  try {
-    await conn.send("DOM.scrollIntoViewIfNeeded", { backendNodeId });
-  } catch {}
+    throw driverError("page-error", "Page.getLayoutMetrics returned no content size");
+  return { x: 0, y: 0, width: Math.ceil(size.width), height: Math.ceil(size.height) };
+}
+async function elementClip(conn, loc) {
+  const backendNodeId = await backendNodeIdOf(conn, loc);
+  await conn.send("DOM.scrollIntoViewIfNeeded", { backendNodeId }).catch(() => {
+    return;
+  });
   const box = await conn.send("DOM.getBoxModel", { backendNodeId });
   const q = box.model.content;
-  const q0 = q[0];
-  const q1 = q[1];
-  if (q0 == null || q1 == null)
-    throw new CdpError("DOM.getBoxModel returned an empty content quad");
   const xs = [q[0], q[2], q[4], q[6]].filter((n) => n != null);
   const ys = [q[1], q[3], q[5], q[7]].filter((n) => n != null);
-  const minX = Math.min(...xs);
-  const minY = Math.min(...ys);
-  const maxX = Math.max(...xs);
-  const maxY = Math.max(...ys);
-  const width = Math.ceil(maxX - minX);
-  const height = Math.ceil(maxY - minY);
+  if (!xs.length || !ys.length)
+    throw driverError("page-error", "DOM.getBoxModel returned an empty content quad");
+  const minX = Math.min(...xs), minY = Math.min(...ys);
+  const width = Math.ceil(Math.max(...xs) - minX), height = Math.ceil(Math.max(...ys) - minY);
   if (width <= 0 || height <= 0)
-    throw new CdpError("resolved element has zero area");
-  return { x: minX, y: minY, width, height, scale: 1 };
-}
-async function takeScreenshot(args = {}) {
-  const { target, fullPage, uid, selector, savePath, returnBase64 } = args;
-  if (uid != null && selector)
-    throw new CdpError("provide exactly one of uid or selector, not both");
-  const format = args.format ?? "png";
-  const quality = format === "jpeg" ? args.quality ?? 80 : undefined;
-  return withPage(target, async (conn, t) => {
-    await conn.send("Page.enable");
-    const params = { format, captureBeyondViewport: true };
-    if (quality != null)
-      params.quality = quality;
-    if (uid != null || selector) {
-      params.clip = await elementClip(conn, uid, selector);
-    } else if (fullPage) {
-      params.clip = await fullPageClip(conn);
-    }
-    const { data } = await conn.send("Page.captureScreenshot", params);
-    const buf = Buffer.from(data, "base64");
-    if (buf.byteLength === 0)
-      throw new CdpError("Page.captureScreenshot returned empty data");
-    await mkdir2(ARTIFACT_DIR, { recursive: true });
-    const ext = format === "jpeg" ? "jpg" : "png";
-    const path = savePath ?? join(ARTIFACT_DIR, `screenshot-${shortId(t.id)}-${stamp()}.${ext}`);
-    await writeFile2(path, buf);
-    const result = {
-      path,
-      bytes: buf.byteLength,
-      format,
-      target: { id: t.id, url: t.url, title: t.title }
-    };
-    if (returnBase64)
-      result.base64 = data;
-    return result;
-  });
+    throw driverError("page-error", "resolved element has zero area");
+  return { x: minX, y: minY, width, height };
 }
+var CDP_CAPABILITIES = new Set([
+  "trace.performance",
+  "heap.snapshot",
+  "audit.lighthouse",
+  "emulate.cpuThrottling",
+  "emulate.mediaFeatures",
+  "emulate.deviceMetrics",
+  "emulate.networkConditions",
+  "screenshot.fullPage",
+  "screenshot.element",
+  "network.intercept",
+  "snapshot.accessibilityTree",
+  "input.insertTextAtomic",
+  "locate.text",
+  "locate.xpath"
+]);
 
-// src/tools/emulation.ts
-async function clearAll(conn) {
-  await conn.send("Emulation.clearDeviceMetricsOverride").catch(() => {
-    return;
-  });
-  await conn.send("Emulation.setUserAgentOverride", { userAgent: "" }).catch(() => {
-    return;
-  });
-  await conn.send("Emulation.setCPUThrottlingRate", { rate: 1 }).catch(() => {
-    return;
-  });
-  await conn.send("Emulation.setEmulatedMedia", { media: "", features: [] }).catch(() => {
-    return;
-  });
-  await conn.send("Network.enable").catch(() => {
-    return;
-  });
-  await conn.send("Network.emulateNetworkConditions", {
-    offline: false,
-    latency: 0,
-    downloadThroughput: -1,
-    uploadThroughput: -1
-  }).catch(() => {
-    return;
-  });
-}
-async function emulate(args = {}) {
-  const { target } = args;
-  return withPage(target, async (conn, t) => {
-    if (args.clearOverrides) {
-      await clearAll(conn);
-      return {
-        target: { id: t.id, url: t.url, title: t.title },
-        applied: [],
-        cleared: true
+class CdpPageDriver {
+  conn;
+  browser;
+  info;
+  enabledDomains = new Set;
+  released = false;
+  constructor(conn, target, browser) {
+    this.conn = conn;
+    this.browser = browser;
+    this.info = { id: target.id, url: target.url, title: target.title, type: target.type };
+  }
+  async ensureDomain(name) {
+    if (this.enabledDomains.has(name))
+      return;
+    this.enabledDomains.add(name);
+    await this.conn.send(`${name}.enable`);
+  }
+  async ensureDomainSoft(name) {
+    if (this.enabledDomains.has(name))
+      return;
+    this.enabledDomains.add(name);
+    await this.conn.send(`${name}.enable`).catch(() => {
+      return;
+    });
+  }
+  async navigate(opts) {
+    await this.ensureDomain("Page");
+    const reload = opts.reload === true;
+    if (!reload && !opts.url)
+      throw driverError("page-error", "navigate: 'url' is required unless reload:true");
+    const waitUntil = opts.waitUntil ?? "load";
+    const milestoneMethod = waitUntil === "load" ? "Page.loadEventFired" : "Page.domContentEventFired";
+    const milestone = this.conn.waitFor(milestoneMethod, undefined, opts.timeoutMs).then(() => waitUntil).catch(() => {
+      return;
+    });
+    const stopped = this.conn.waitFor("Page.frameStoppedLoading", undefined, opts.timeoutMs).then(() => "committed").catch(() => {
+      return;
+    });
+    let url, contextId, reloaded;
+    if (reload) {
+      await this.conn.send("Page.reload", { ignoreCache: opts.ignoreCache === true }, opts.timeoutMs ? { timeoutMs: opts.timeoutMs } : {});
+      const tree = await this.conn.send("Page.getFrameTree").catch(() => {
+        return;
+      });
+      contextId = tree?.frameTree?.frame?.id ?? "";
+      url = tree?.frameTree?.frame?.url ?? opts.url ?? "";
+      reloaded = true;
+    } else {
+      const nav = await this.conn.send("Page.navigate", { url: opts.url }, opts.timeoutMs ? { timeoutMs: opts.timeoutMs } : {});
+      if (nav.errorText)
+        throw driverError("page-error", `navigate: ${nav.errorText} (${opts.url})`);
+      contextId = nav.frameId;
+      url = opts.url;
+    }
+    const settled = await Promise.race([milestone, stopped]);
+    return { url, contextId, ...reloaded ? { reloaded } : {}, waitedFor: settled ?? "timeout" };
+  }
+  async waitForText(text, timeoutMs = 15000, pollMs = 250) {
+    await this.ensureDomain("Runtime");
+    const start = Date.now();
+    const expr = `(() => { const b = document.body; return !!b && typeof b.innerText === 'string' && b.innerText.includes(${JSON.stringify(text)}); })()`;
+    for (;; ) {
+      const { result } = await this.conn.send("Runtime.evaluate", { expression: expr, returnByValue: true });
+      if (result?.value === true)
+        return { found: true, elapsedMs: Date.now() - start };
+      if (Date.now() - start >= timeoutMs)
+        throw driverError("timeout", `waitForText: '${text}' not found within ${timeoutMs}ms`);
+      await new Promise((r) => setTimeout(r, Math.min(pollMs, Math.max(0, timeoutMs - (Date.now() - start)))));
+    }
+  }
+  async callFn(objectId, functionDeclaration, args, awaitPromise) {
+    const res = await this.conn.send("Runtime.callFunctionOn", { objectId, functionDeclaration, arguments: args.map((value) => ({ value })), returnByValue: true, awaitPromise });
+    if (res.exceptionDetails)
+      throw driverError("page-error", exceptionMessage(res.exceptionDetails));
+    return unwrap(res.result);
+  }
+  async evaluate(expression, opts) {
+    await this.ensureDomain("Runtime");
+    const awaitPromise = opts?.awaitPromise ?? true;
+    if (opts?.args && opts.args.length > 0) {
+      const globalObj = await this.conn.send("Runtime.evaluate", { expression: "globalThis", returnByValue: false });
+      const objectId = globalObj.result.objectId;
+      if (!objectId)
+        throw driverError("page-error", "could not resolve global object for function call");
+      return this.callFn(objectId, expression, opts.args, awaitPromise);
+    }
+    const res = await this.conn.send("Runtime.evaluate", { expression, returnByValue: true, awaitPromise });
+    if (res.exceptionDetails)
+      throw driverError("page-error", exceptionMessage(res.exceptionDetails));
+    return unwrap(res.result);
+  }
+  async callOnElement(loc, functionDeclaration, args = []) {
+    const { objectId } = await resolveElementLocator(this.conn, loc);
+    return this.callFn(objectId, functionDeclaration, args, true);
+  }
+  async snapshot(opts) {
+    const interactiveOnly = opts?.interactiveOnly ?? false;
+    await this.ensureDomain("Accessibility");
+    const { nodes } = await this.conn.send("Accessibility.getFullAXTree");
+    const byId = new Map;
+    for (const n of nodes)
+      byId.set(n.nodeId, n);
+    const roots = nodes.filter((n) => !n.parentId || !byId.has(n.parentId));
+    const out = [];
+    const walk = (node, depth) => {
+      const role = axString(node.role);
+      const name = axString(node.name);
+      const backendNodeId = node.backendDOMNodeId;
+      const emitted = !node.ignored && backendNodeId !== undefined && (interactiveOnly ? isInteractive(role) : !!(role || name));
+      if (emitted) {
+        const extras = axExtras(node);
+        out.push({ uid: encodeUid(backendNodeId), role: role ?? "generic", depth, ...name ? { name } : {}, ...Object.keys(extras).length ? { extras } : {} });
+      }
+      const childDepth = emitted && !interactiveOnly ? depth + 1 : depth;
+      for (const childId of node.childIds ?? []) {
+        const child = byId.get(childId);
+        if (child)
+          walk(child, childDepth);
+      }
+    };
+    for (const root of roots)
+      walk(root, 0);
+    return out;
+  }
+  async locate(loc) {
+    return encodeUid(await backendNodeIdOf(this.conn, loc));
+  }
+  async resolve(uid) {
+    await resolveUid(this.conn, decodeUid(uid)).catch(() => {
+      throw driverError("stale-uid", `uid does not resolve: ${uid}`);
+    });
+  }
+  async hover(loc) {
+    const { objectId } = await resolveElementLocator(this.conn, loc);
+    const { x, y } = await centerOf(this.conn, objectId);
+    await this.conn.send("Input.dispatchMouseEvent", { type: "mouseMoved", x, y });
+    return { x, y };
+  }
+  async click(loc, opts) {
+    const button = opts?.button ?? "left";
+    const clickCount = opts?.clickCount ?? 1;
+    const { x, y } = await this.hover(loc);
+    await this.conn.send("Input.dispatchMouseEvent", { type: "mousePressed", x, y, button, clickCount });
+    await this.conn.send("Input.dispatchMouseEvent", { type: "mouseReleased", x, y, button, clickCount });
+    return { x, y };
+  }
+  async drag(from, to) {
+    const fromPt = await this.hover(from);
+    const { objectId: dstId } = await resolveElementLocator(this.conn, to);
+    const toPt = await centerOf(this.conn, dstId);
+    await this.conn.send("Input.dispatchMouseEvent", { type: "mousePressed", x: fromPt.x, y: fromPt.y, button: "left", clickCount: 1 });
+    await this.conn.send("Input.dispatchMouseEvent", { type: "mouseMoved", x: (fromPt.x + toPt.x) / 2, y: (fromPt.y + toPt.y) / 2, button: "left" });
+    await this.conn.send("Input.dispatchMouseEvent", { type: "mouseMoved", x: toPt.x, y: toPt.y, button: "left" });
+    await this.conn.send("Input.dispatchMouseEvent", { type: "mouseReleased", x: toPt.x, y: toPt.y, button: "left", clickCount: 1 });
+    return { from: fromPt, to: toPt };
+  }
+  async setValue(loc, value) {
+    const { objectId } = await resolveElementLocator(this.conn, loc);
+    await setValueOnObject(this.conn, objectId, value);
+  }
+  async typeText(loc, text) {
+    const { objectId } = await resolveElementLocator(this.conn, loc);
+    await focusElement(this.conn, objectId);
+    if (text.length)
+      await this.conn.send("Input.insertText", { text });
+  }
+  async pressKey(press) {
+    const spec = resolveKey(press.key);
+    let modBits = 0;
+    for (const m of press.modifiers ?? []) {
+      const bit = MODIFIER_BITS[m.toLowerCase()];
+      if (bit === undefined)
+        throw driverError("page-error", `unknown modifier '${m}'`);
+      modBits |= bit;
+    }
+    const suppressText = (modBits & ~MODIFIER_BITS.shift) !== 0;
+    const down = { type: "keyDown", key: spec.key, code: spec.code, windowsVirtualKeyCode: spec.keyCode, nativeVirtualKeyCode: spec.keyCode, modifiers: modBits };
+    if (spec.text && !suppressText)
+      down.text = spec.text;
+    await this.conn.send("Input.dispatchKeyEvent", down);
+    await this.conn.send("Input.dispatchKeyEvent", { type: "keyUp", key: spec.key, code: spec.code, windowsVirtualKeyCode: spec.keyCode, nativeVirtualKeyCode: spec.keyCode, modifiers: modBits });
+  }
+  async setFiles(loc, files) {
+    const { objectId } = await resolveElementLocator(this.conn, loc);
+    await this.conn.send("DOM.setFileInputFiles", { files: [...files], objectId });
+  }
+  async screenshot(opts) {
+    await this.ensureDomain("Page");
+    const format = opts?.format ?? "png";
+    const quality = format === "jpeg" ? opts?.quality ?? 80 : undefined;
+    const params = { format, captureBeyondViewport: true };
+    if (quality != null)
+      params.quality = quality;
+    if (opts?.clip)
+      params.clip = { ...await elementClip(this.conn, opts.clip), scale: 1 };
+    else if (opts?.fullPage)
+      params.clip = { ...await fullPageClip(this.conn), scale: 1 };
+    const { data } = await this.conn.send("Page.captureScreenshot", params);
+    return { data: new Uint8Array(Buffer.from(data, "base64")), format };
+  }
+  async emulate(opts) {
+    if (opts.clearOverrides) {
+      const c = () => {
+        return;
       };
+      await this.conn.send("Emulation.clearDeviceMetricsOverride").catch(c);
+      await this.conn.send("Emulation.setUserAgentOverride", { userAgent: "" }).catch(c);
+      await this.conn.send("Emulation.setCPUThrottlingRate", { rate: 1 }).catch(c);
+      await this.conn.send("Emulation.setEmulatedMedia", { media: "", features: [] }).catch(c);
+      await this.ensureDomainSoft("Network");
+      await this.conn.send("Network.emulateNetworkConditions", { offline: false, latency: 0, downloadThroughput: -1, uploadThroughput: -1 }).catch(c);
+      return { applied: [] };
     }
     const applied = [];
-    if (args.width != null || args.height != null) {
-      if (args.width == null || args.height == null) {
-        throw new CdpError("emulate device metrics require both width and height");
+    if (opts.width != null || opts.height != null) {
+      if (opts.width == null || opts.height == null) {
+        throw driverError("page-error", "emulate device metrics require both width and height");
       }
-      await conn.send("Emulation.setDeviceMetricsOverride", {
-        width: args.width,
-        height: args.height,
-        deviceScaleFactor: args.deviceScaleFactor ?? 0,
-        mobile: args.mobile ?? false
+      await this.conn.send("Emulation.setDeviceMetricsOverride", {
+        width: opts.width,
+        height: opts.height,
+        deviceScaleFactor: opts.deviceScaleFactor ?? 0,
+        mobile: opts.mobile ?? false
       });
       applied.push("deviceMetrics");
     }
-    if (args.userAgent != null) {
-      await conn.send("Emulation.setUserAgentOverride", { userAgent: args.userAgent });
+    if (opts.userAgent != null) {
+      await this.conn.send("Emulation.setUserAgentOverride", { userAgent: opts.userAgent });
       applied.push("userAgent");
     }
-    if (args.cpuThrottlingRate != null) {
-      if (args.cpuThrottlingRate < 1)
-        throw new CdpError("cpuThrottlingRate must be >= 1");
-      await conn.send("Emulation.setCPUThrottlingRate", { rate: args.cpuThrottlingRate });
+    if (opts.cpuThrottlingRate != null) {
+      if (opts.cpuThrottlingRate < 1)
+        throw driverError("page-error", "cpuThrottlingRate must be >= 1");
+      await this.conn.send("Emulation.setCPUThrottlingRate", { rate: opts.cpuThrottlingRate });
       applied.push("cpuThrottlingRate");
     }
-    if (args.media != null || args.mediaFeatures != null) {
-      await conn.send("Emulation.setEmulatedMedia", {
-        media: args.media ?? "",
-        features: args.mediaFeatures ?? []
-      });
+    if (opts.media != null || opts.mediaFeatures != null) {
+      await this.conn.send("Emulation.setEmulatedMedia", { media: opts.media ?? "", features: opts.mediaFeatures ?? [] });
       applied.push("emulatedMedia");
     }
-    if (args.networkConditions != null) {
-      const n = args.networkConditions;
-      await conn.send("Network.enable").catch(() => {
-        return;
-      });
-      await conn.send("Network.emulateNetworkConditions", {
+    if (opts.networkConditions != null) {
+      const n = opts.networkConditions;
+      await this.ensureDomainSoft("Network");
+      await this.conn.send("Network.emulateNetworkConditions", {
         offline: n.offline ?? false,
         latency: n.latency ?? 0,
         downloadThroughput: n.downloadThroughput ?? -1,
@@ -921,227 +1164,674 @@ async function emulate(args = {}) {
       });
       applied.push("networkConditions");
     }
-    if (applied.length === 0) {
-      throw new CdpError("emulate: no overrides specified (pass clearOverrides:true to reset)");
+    return { applied };
+  }
+  static EVENT_MAP = {
+    navigated: { method: "Page.frameNavigated" },
+    console: { method: "Runtime.consoleAPICalled" },
+    "network.request": { method: "Network.requestWillBeSent", domain: "Network" },
+    "network.response": { method: "Network.responseReceived", domain: "Network" },
+    dialog: { method: "Page.javascriptDialogOpening" },
+    "page.closed": { method: "Inspector.detached", domain: "Inspector" }
+  };
+  on(event, handler) {
+    const spec = CdpPageDriver.EVENT_MAP[event];
+    if (spec.domain && !this.enabledDomains.has(spec.domain)) {
+      this.enabledDomains.add(spec.domain);
+      this.conn.send(`${spec.domain}.enable`);
     }
-    return { target: { id: t.id, url: t.url, title: t.title }, applied };
-  });
-}
-async function resizePage(args) {
-  const { target, width, height } = args;
-  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
-    throw new CdpError("resize_page requires positive numeric width and height");
-  }
-  return withPage(target, async (conn, t) => {
-    await conn.send("Emulation.setDeviceMetricsOverride", {
-      width,
-      height,
-      deviceScaleFactor: args.deviceScaleFactor ?? 0,
-      mobile: args.mobile ?? false
-    });
-    await conn.send("Runtime.enable").catch(() => {
-      return;
-    });
-    const { result } = await conn.send("Runtime.evaluate", {
-      expression: "({ w: window.innerWidth, h: window.innerHeight })",
-      returnByValue: true
+    return this.conn.on(spec.method, (params) => handler(params));
+  }
+  async waitForEvent(event, predicate, timeoutMs) {
+    const spec = CdpPageDriver.EVENT_MAP[event];
+    if (spec.domain)
+      await this.ensureDomain(spec.domain);
+    return this.conn.waitFor(spec.method, predicate, timeoutMs);
+  }
+  armDialog(accept, promptText, onHandled) {
+    return this.conn.on("Page.javascriptDialogOpening", (params) => {
+      const p = params;
+      this.conn.send("Page.handleJavaScriptDialog", { accept, ...promptText !== undefined ? { promptText } : {} }).then(() => onHandled({
+        type: p.type,
+        message: p.message,
+        url: p.url,
+        ...p.defaultPrompt !== undefined ? { defaultPrompt: p.defaultPrompt } : {},
+        accept,
+        ...promptText !== undefined ? { promptText } : {},
+        handled: true
+      })).catch(() => {
+        return;
+      });
     });
-    const v = result.value;
-    return {
-      target: { id: t.id, url: t.url, title: t.title },
-      width,
-      height,
-      innerWidth: v?.w ?? width,
-      innerHeight: v?.h ?? height
-    };
-  });
-}
-
-// src/tools/dialogs.ts
-function armDialogHandler(conn, accept, promptText, onHandled) {
-  return conn.on("Page.javascriptDialogOpening", (params) => {
-    const ev = params;
-    (async () => {
-      try {
-        await conn.send("Page.handleJavaScriptDialog", {
-          accept,
-          ...promptText !== undefined ? { promptText } : {}
-        });
-        onHandled({
-          type: ev.type,
-          message: ev.message,
-          url: ev.url,
-          ...ev.defaultPrompt !== undefined ? { defaultPrompt: ev.defaultPrompt } : {},
-          accept,
-          ...promptText !== undefined ? { promptText } : {},
-          handled: true
-        });
-      } catch {}
-    })();
-  });
-}
-async function handleDialog(args) {
-  const { target, accept, promptText, timeoutMs = 15000, autoMs } = args;
-  const { conn } = await openPage(target);
-  try {
-    await conn.send("Page.enable");
-    if (autoMs !== undefined) {
+  }
+  async handleDialog(accept, promptText, opts) {
+    await this.ensureDomain("Page");
+    if (opts?.autoMs !== undefined) {
       const handled = [];
-      const disarm = armDialogHandler(conn, accept, promptText, (d) => handled.push(d));
-      await new Promise((resolve) => setTimeout(resolve, autoMs));
-      disarm();
+      const off = this.armDialog(accept, promptText, (d) => handled.push(d));
+      await new Promise((resolve) => setTimeout(resolve, opts.autoMs));
+      off();
       return { handled, count: handled.length };
     }
-    return await new Promise((resolve, reject) => {
+    const timeoutMs = opts?.timeoutMs ?? 15000;
+    return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
-        disarm();
-        reject(new CdpError(`handle_dialog: no dialog opened within ${timeoutMs}ms`));
+        off();
+        reject(driverError("timeout", `handleDialog: no dialog opened within ${timeoutMs}ms`));
       }, timeoutMs);
-      const disarm = armDialogHandler(conn, accept, promptText, (d) => {
+      const off = this.armDialog(accept, promptText, (d) => {
         clearTimeout(timer);
-        disarm();
+        off();
         resolve(d);
       });
     });
+  }
+  async startBodyCapture() {
+    await this.ensureDomain("Network");
+    return async () => {
+      await this.conn.send("Network.disable").catch(() => {
+        return;
+      });
+      this.enabledDomains.delete("Network");
+    };
+  }
+  async getResponseBody(requestId) {
+    return this.conn.send("Network.getResponseBody", { requestId });
+  }
+  async intercept(rules) {
+    await this.conn.send("Fetch.enable", { patterns: rules.map((r) => ({ urlPattern: r.urlPattern })) });
+    let chain = Promise.resolve();
+    const off = this.conn.on("Fetch.requestPaused", (params) => {
+      const p = params;
+      chain = chain.then(async () => {
+        const rule = selectRule(rules, p.request.url, p.request.method);
+        if (!rule) {
+          await this.conn.send("Fetch.continueRequest", { requestId: p.requestId });
+          return;
+        }
+        if (rule.delayMs)
+          await new Promise((r) => setTimeout(r, rule.delayMs));
+        const act = effectiveAction(rule, Math.random());
+        if (act === "fulfill")
+          await this.conn.send("Fetch.fulfillRequest", { ...buildFulfillParams(p.requestId, rule) });
+        else if (act === "fail")
+          await this.conn.send("Fetch.failRequest", { requestId: p.requestId, errorReason: rule.errorReason ?? "Failed" });
+        else
+          await this.conn.send("Fetch.continueRequest", { requestId: p.requestId });
+      }).catch(() => {
+        return;
+      });
+    });
+    return async () => {
+      off();
+      await this.conn.send("Fetch.disable").catch(() => {
+        return;
+      });
+    };
+  }
+  async release() {
+    if (this.released)
+      return;
+    this.released = true;
+    this.conn.close();
+  }
+}
+async function withBrowserConn(fn) {
+  const conn = await openBrowser();
+  try {
+    return await fn(conn);
   } finally {
     conn.close();
   }
 }
-
-// src/tools/console.ts
-import { readFile } from "node:fs/promises";
-
-// src/tools/recorder.ts
-import { mkdir as mkdir3, appendFile, writeFile as writeFile3, copyFile } from "node:fs/promises";
-var ARTIFACT_DIR2 = process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
-function recFile(targetId) {
-  return `${ARTIFACT_DIR2}/rec-${targetId}.jsonl`;
-}
-function captureFile(targetId, captureId) {
-  return `${ARTIFACT_DIR2}/rec-${targetId}-${captureId}.jsonl`;
-}
-function delay2(ms) {
-  return new Promise((r) => setTimeout(r, ms));
+function noSuchTarget(e) {
+  throw driverError("no-such-target", e instanceof CdpError ? e.message : String(e));
 }
-var NETWORK_EVENTS = [
-  "Network.requestWillBeSent",
-  "Network.responseReceived",
-  "Network.loadingFinished",
-  "Network.loadingFailed"
-];
-var CONSOLE_EVENTS = ["Runtime.consoleAPICalled", "Runtime.exceptionThrown", "Log.entryAdded"];
-async function startRecorder(target, opts = {}) {
-  const network = opts.network ?? true;
-  const consoleCap = opts.console ?? true;
-  await mkdir3(ARTIFACT_DIR2, { recursive: true });
-  const { conn, target: resolved } = await openPage(target, { timeoutMs: opts.timeoutMs });
-  const file = opts.file ?? recFile(resolved.id);
-  if (opts.truncate) {
-    await writeFile3(file, "");
+
+class CdpBrowserDriver {
+  scheme = "cdp";
+  lifetime = "per-call";
+  capabilities = CDP_CAPABILITIES;
+  uidStability = "browser-node";
+  snapshotFidelity = "accessibility-tree";
+  async listPages(opts) {
+    const targets = await listTargets();
+    const filtered = opts?.all ? targets : targets.filter((t) => t.type === "page");
+    return filtered.map((t) => ({ id: t.id, url: t.url, title: t.title, type: t.type }));
   }
-  let chain = Promise.resolve();
-  let dropped = 0;
-  const persist = (kind, method, params) => {
-    const line = { kind, method, ts: Date.now(), params };
-    const text = `${JSON.stringify(line)}
-`;
-    chain = chain.then(() => appendFile(file, text)).catch(() => {
-      dropped += 1;
+  async newPage(url) {
+    return withBrowserConn(async (conn) => {
+      const { targetId } = await conn.send("Target.createTarget", { url: url ?? "about:blank" });
+      if (!targetId)
+        throw driverError("page-error", "Target.createTarget returned no targetId");
+      return { id: targetId, url: url ?? "about:blank", title: "" };
     });
-  };
-  const unsubs = [];
-  try {
-    if (network) {
-      await conn.send("Network.enable");
-      for (const ev of NETWORK_EVENTS) {
-        unsubs.push(conn.on(ev, (params) => persist("network", ev, params)));
-      }
-    }
-    if (consoleCap) {
-      await conn.send("Runtime.enable");
-      try {
-        await conn.send("Log.enable");
-      } catch {}
-      for (const ev of CONSOLE_EVENTS) {
-        unsubs.push(conn.on(ev, (params) => persist("console", ev, params)));
-      }
-    }
-  } catch (err) {
-    conn.close();
-    throw err;
   }
-  const flush = async () => {
-    for (const off of unsubs)
-      off();
-    await chain;
-  };
-  return {
-    file,
-    target: resolved,
-    conn,
-    droppedWrites: () => dropped,
-    flush,
-    async stop() {
-      await flush();
-      conn.close();
-    }
-  };
+  async closePage(id) {
+    return withBrowserConn(async (conn) => {
+      const res = await conn.send("Target.closeTarget", { targetId: id });
+      return { success: res.success ?? true };
+    });
+  }
+  async activatePage(id) {
+    const target = await resolveTarget(id).catch(noSuchTarget);
+    await withBrowserConn((conn) => conn.send("Target.activateTarget", { targetId: target.id }));
+    return { id: target.id, url: target.url, title: target.title };
+  }
+  async page(selector) {
+    const { conn, target } = await openPage(selector).catch(noSuchTarget);
+    return new CdpPageDriver(conn, target, this);
+  }
+  async dispose() {}
 }
-async function captureWindow(target, durationMs, opts = {}) {
-  const resolved = await resolveTarget(target);
-  const captureId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-  const file = captureFile(resolved.id, captureId);
-  const rec = await startRecorder(resolved.id, {
-    network: true,
-    console: true,
-    truncate: true,
-    file,
-    timeoutMs: opts.timeoutMs
+function createCdpDriver() {
+  return new CdpBrowserDriver;
+}
+
+// src/leases-tools.ts
+class LeaseToolError extends Error {
+}
+function backendOf(driver) {
+  return driver.scheme === "bidi" ? "firefox" : "chrome";
+}
+async function claimPage(driver, args = {}) {
+  const backend = backendOf(driver);
+  const label = typeof args.label === "string" && args.label.length ? args.label : `pid-${process.pid}`;
+  const pages = await driver.listPages();
+  let targetId = args.targetId;
+  let url = args.url ?? "about:blank";
+  if (targetId === undefined || targetId === "") {
+    const page = await driver.newPage(args.url);
+    targetId = page.id;
+    url = page.url;
+  } else {
+    const existing = pages.find((p) => p.id === targetId);
+    if (!existing)
+      throw new LeaseToolError(`claim_page: no page target with id '${targetId}'`);
+    url = existing.url;
+  }
+  const liveIds = [...pages.map((p) => p.id), targetId];
+  const { record, token } = await claimLease(backend, targetId, {
+    label,
+    ttlMs: typeof args.ttlMs === "number" && args.ttlMs > 0 ? args.ttlMs : leaseTtlMs(),
+    liveIds
   });
-  await rec.conn.send("Page.enable");
-  await rec.conn.send("Page.reload", { ignoreCache: false });
-  await delay2(durationMs);
   return {
-    file: rec.file,
-    conn: rec.conn,
-    resolved: { id: rec.target.id, url: rec.target.url, title: rec.target.title },
-    droppedWrites: rec.droppedWrites,
-    flush: () => rec.flush(),
-    async stop() {
-      await rec.stop();
-      try {
-        await copyFile(rec.file, recFile(rec.target.id));
-      } catch {}
-    }
+    lease: token,
+    targetId,
+    url,
+    label: record.label,
+    ttlMs: record.ttlMs,
+    expiresAt: record.lastUsedAt + record.ttlMs
   };
 }
+async function releasePage(_driver, args) {
+  if (typeof args.lease !== "string" || !args.lease.length) {
+    throw new LeaseToolError("release_page requires the 'lease' token returned by claim_page");
+  }
+  return releaseLease(args.lease);
+}
+async function listLeasesTool(driver, _args = {}) {
+  const liveIds = (await driver.listPages()).map((p) => p.id);
+  const leases = await listLeases({ liveIds, liveBackend: backendOf(driver) });
+  return { leases, count: leases.length };
+}
+var LEASE_TOOLS = {
+  claim_page: claimPage,
+  release_page: releasePage,
+  list_leases: listLeasesTool
+};
 
-// src/tools/console.ts
-var DEFAULT_CAPTURE_MS = 2500;
-function remoteObjectToText(arg) {
-  if (!arg)
-    return "";
-  if (arg.value !== undefined && arg.value !== null)
-    return String(arg.value);
-  if (typeof arg.description === "string")
-    return arg.description;
-  if (typeof arg.unserializableValue === "string")
-    return arg.unserializableValue;
-  if (arg.type === "undefined")
-    return "undefined";
-  if (arg.type === "object" && arg.subtype === "null")
-    return "null";
-  if (typeof arg.type === "string")
-    return `[${arg.type}]`;
-  return "";
+// src/shared-tools.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+var ARTIFACT_DIR = process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
+var STATE_DIR = process.env.CDP_STATE_DIR ?? "/tmp/cdp-toolkit";
+
+class SharedToolError extends Error {
 }
-function lineToEntry(line, index) {
-  const p = line.params;
-  if (line.method === "Runtime.consoleAPICalled") {
-    const args = Array.isArray(p.args) ? p.args : [];
-    return {
-      index,
-      source: "console",
+function target3(p) {
+  return { id: p.id, url: p.url, title: p.title };
+}
+function backendOf2(driver) {
+  return driver.scheme === "bidi" ? "firefox" : "chrome";
+}
+async function withPage2(driver, target, fn) {
+  const page = await driver.page(target);
+  try {
+    return await fn(page);
+  } finally {
+    await page.release();
+  }
+}
+async function resolvePage(driver, selector) {
+  const pages = await driver.listPages();
+  const hit = await pickPage(driver, pages, selector);
+  await assertLeaseOk(backendOf2(driver), hit.id, { url: hit.url, title: hit.title });
+  return hit;
+}
+async function pickPage(driver, pages, selector) {
+  if (selector === undefined || selector === "active") {
+    if (!pages.length)
+      throw new SharedToolError("no page targets open");
+    return pages[0];
+  }
+  if (selector.startsWith("index:")) {
+    const p = pages[Number(selector.slice(6))];
+    if (!p)
+      throw new SharedToolError(`no page target at index ${selector.slice(6)} (have ${pages.length})`);
+    return p;
+  }
+  if (selector.startsWith("url:")) {
+    const needle = selector.slice(4);
+    const p = pages.find((x) => x.url.includes(needle));
+    if (!p)
+      throw new SharedToolError(`no page url containing '${needle}'`);
+    return p;
+  }
+  if (selector.startsWith("title:")) {
+    const needle = selector.slice(6);
+    const p = pages.find((x) => x.title.includes(needle));
+    if (!p)
+      throw new SharedToolError(`no page title containing '${needle}'`);
+    return p;
+  }
+  const exactPage = pages.find((x) => x.id === selector);
+  if (exactPage)
+    return exactPage;
+  const all = await driver.listPages({ all: true });
+  const exact = all.find((x) => x.id === selector);
+  if (exact)
+    return exact;
+  throw new SharedToolError(`no target with id '${selector}'`);
+}
+function locatorOf(args) {
+  const hasUid = args.uid !== undefined && args.uid !== null && args.uid !== "";
+  const hasSelector = typeof args.selector === "string" && args.selector.length > 0;
+  if (hasUid === hasSelector)
+    throw new SharedToolError("provide exactly one of { uid } or { selector }");
+  return hasUid ? { uid: args.uid } : { css: args.selector };
+}
+async function listPages(driver, args = {}) {
+  const pages = await driver.listPages({ all: args.all });
+  return { pages, count: pages.length };
+}
+async function newPage(driver, args = {}) {
+  const p = await driver.newPage(args.url);
+  if (args.claim !== true)
+    return { targetId: p.id, url: p.url };
+  const { record, token } = await claimLease(backendOf2(driver), p.id, {
+    label: typeof args.label === "string" && args.label.length ? args.label : `pid-${process.pid}`,
+    ttlMs: typeof args.ttlMs === "number" && args.ttlMs > 0 ? args.ttlMs : leaseTtlMs()
+  });
+  return { targetId: p.id, url: p.url, lease: token, label: record.label, expiresAt: record.lastUsedAt + record.ttlMs };
+}
+async function closePage(driver, args) {
+  if (args.target === undefined || args.target === "")
+    throw new SharedToolError("close_page requires an explicit target; refusing to guess which page to close");
+  const p = await resolvePage(driver, args.target);
+  const res = await driver.closePage(p.id);
+  if (!res.success)
+    return { closed: p.id, success: false, leaseReleased: false };
+  const released = await releaseLeaseFor(backendOf2(driver), p.id);
+  return { closed: p.id, success: true, ...released.released ? { leaseReleased: true } : {} };
+}
+async function writeSelectedFile(id) {
+  await mkdir2(STATE_DIR, { recursive: true });
+  await writeFile2(join2(STATE_DIR, "selected"), id, "utf8");
+}
+async function selectPage(driver, args) {
+  if (args.target === undefined || args.target === "")
+    throw new SharedToolError("select_page requires an explicit target");
+  const p = await resolvePage(driver, args.target);
+  const activated = await driver.activatePage(p.id);
+  await writeSelectedFile(activated.id);
+  return { selected: activated.id };
+}
+function toLegacyWaitedFor(w) {
+  if (w === "committed")
+    return "frameStoppedLoading";
+  if (w === "timeout")
+    return "navigate-only";
+  return w;
+}
+async function navigatePage(driver, args) {
+  const reload = args.reload === true;
+  if (!reload && (!args.url || typeof args.url !== "string")) {
+    throw new SharedToolError("navigate_page: 'url' is required (or pass reload:true to reload the current page)");
+  }
+  return withPage2(driver, args.target, async (page) => {
+    const r = await page.navigate(args);
+    return {
+      url: r.url,
+      frameId: r.contextId,
+      ...r.reloaded ? { reloaded: r.reloaded } : {},
+      waitedFor: toLegacyWaitedFor(r.waitedFor)
+    };
+  });
+}
+async function waitForText(driver, args) {
+  if (typeof args.text !== "string" || args.text.length === 0)
+    throw new SharedToolError("wait_for: 'text' is required");
+  return withPage2(driver, args.target, async (page) => {
+    const r = await page.waitForText(args.text, args.timeoutMs ?? 15000, args.pollMs ?? 250);
+    return { found: true, waitedMs: r.elapsedMs };
+  });
+}
+async function evaluateScript(driver, args) {
+  if (typeof args.expression !== "string" || args.expression.length === 0) {
+    throw new SharedToolError("evaluateScript: 'expression' must be a non-empty string");
+  }
+  return withPage2(driver, args.target, (page) => page.evaluate(args.expression, { args: args.args, awaitPromise: args.awaitPromise ?? true }));
+}
+var BARE_TOKEN_EXTRAS = new Set(["disabled", "focused"]);
+var UNQUOTED_EXTRAS = new Set(["checked", "expanded", "url"]);
+function renderSnapshotLine(n, scheme) {
+  const indent = "  ".repeat(n.depth);
+  const uidText = scheme === "cdp" && n.uid.startsWith("cdp:") ? n.uid.slice(4) : n.uid;
+  const name = n.name !== undefined ? ` ${JSON.stringify(n.name)}` : "";
+  const extrasToks = [];
+  if (n.extras) {
+    for (const [k, v] of Object.entries(n.extras)) {
+      if (BARE_TOKEN_EXTRAS.has(k))
+        extrasToks.push(k);
+      else if (UNQUOTED_EXTRAS.has(k))
+        extrasToks.push(`${k}=${v}`);
+      else
+        extrasToks.push(`${k}=${JSON.stringify(v)}`);
+    }
+  }
+  const extra = extrasToks.length ? ` [${extrasToks.join(" ")}]` : "";
+  return `${indent}[${uidText}] ${n.role}${name}${extra}`;
+}
+async function takeSnapshot(driver, args = {}) {
+  return withPage2(driver, args.target, async (page) => {
+    const nodes = await page.snapshot({ interactiveOnly: args.interactiveOnly ?? false });
+    const scheme = page.browser.scheme;
+    return { snapshot: nodes.map((n) => renderSnapshotLine(n, scheme)).join(`
+`), target: target3(page.info), nodeCount: nodes.length };
+  });
+}
+async function click(driver, args) {
+  return withPage2(driver, args.target, async (page) => {
+    const { x, y } = await page.click(locatorOf(args), { button: args.button ?? "left", clickCount: args.clickCount ?? 1 });
+    return { clicked: true, x, y };
+  });
+}
+async function hover(driver, args) {
+  return withPage2(driver, args.target, async (page) => {
+    const { x, y } = await page.hover(locatorOf(args));
+    return { hovered: true, x, y };
+  });
+}
+async function drag(driver, args) {
+  if (!args.from || !args.to)
+    throw new SharedToolError("drag requires { from } and { to }");
+  return withPage2(driver, args.target, async (page) => {
+    const { from, to } = await page.drag(locatorOf(args.from), locatorOf(args.to));
+    return { dragged: true, from, to };
+  });
+}
+async function fill(driver, args) {
+  if (typeof args.value !== "string")
+    throw new SharedToolError("fill requires a string { value }");
+  return withPage2(driver, args.target, async (page) => {
+    await page.setValue(locatorOf(args), args.value);
+    return { filled: true, value: args.value };
+  });
+}
+async function fillForm(driver, args) {
+  if (!Array.isArray(args.fields) || args.fields.length === 0)
+    throw new SharedToolError("fill_form requires a non-empty { fields } array");
+  return withPage2(driver, args.target, async (page) => {
+    let filled = 0;
+    for (const f of args.fields) {
+      if (typeof f.value !== "string")
+        throw new SharedToolError("each fill_form field requires a string value");
+      await page.setValue(locatorOf(f), f.value);
+      filled++;
+    }
+    return { filled, fields: args.fields.length };
+  });
+}
+async function typeText(driver, args) {
+  if (typeof args.text !== "string")
+    throw new SharedToolError("type_text requires a string { text }");
+  return withPage2(driver, args.target, async (page) => {
+    await page.typeText(locatorOf(args), args.text);
+    return { typed: true, text: args.text };
+  });
+}
+async function pressKey(driver, args) {
+  if (typeof args.key !== "string" || !args.key.length)
+    throw new SharedToolError("press_key requires a non-empty { key }");
+  const modifiers = args.modifiers ?? [];
+  return withPage2(driver, args.target, async (page) => {
+    await page.pressKey({ key: args.key, modifiers });
+    return { pressed: args.key, modifiers };
+  });
+}
+async function uploadFile(driver, args) {
+  const files = Array.isArray(args.files) ? args.files : [args.files];
+  if (!files.length || files.some((f) => typeof f !== "string" || !f.length)) {
+    throw new SharedToolError("upload_file requires { files } as a non-empty path or array of paths");
+  }
+  return withPage2(driver, args.target, async (page) => {
+    await page.setFiles(locatorOf(args), files);
+    return { uploaded: files };
+  });
+}
+function stamp() {
+  return new Date(Date.now()).toISOString().replace(/[:.]/g, "-");
+}
+async function takeScreenshot(driver, args = {}) {
+  if (args.uid !== undefined && args.uid !== "" && args.selector)
+    throw new SharedToolError("provide exactly one of uid or selector, not both");
+  const format = args.format ?? "png";
+  return withPage2(driver, args.target, async (page) => {
+    const clip = args.uid !== undefined || args.selector ? locatorOf(args) : undefined;
+    const { data, format: outFormat } = await page.screenshot({ format, quality: args.quality, fullPage: args.fullPage, ...clip ? { clip } : {} });
+    if (data.byteLength === 0)
+      throw new SharedToolError("captureScreenshot returned empty data");
+    await mkdir2(ARTIFACT_DIR, { recursive: true });
+    const ext = outFormat === "jpeg" ? "jpg" : "png";
+    const path = args.savePath ?? join2(ARTIFACT_DIR, `screenshot-${page.info.id.slice(0, 8)}-${stamp()}.${ext}`);
+    await writeFile2(path, Buffer.from(data));
+    const result = {
+      path,
+      bytes: data.byteLength,
+      format: outFormat,
+      target: target3(page.info)
+    };
+    if (args.returnBase64)
+      result.base64 = Buffer.from(data).toString("base64");
+    return result;
+  });
+}
+async function emulate(driver, args = {}) {
+  return withPage2(driver, args.target, async (page) => {
+    if (args.clearOverrides) {
+      await page.emulate({ clearOverrides: true });
+      return { target: target3(page.info), applied: [], cleared: true };
+    }
+    const { applied } = await page.emulate(args);
+    if (applied.length === 0)
+      throw new SharedToolError("emulate: no overrides specified (pass clearOverrides:true to reset)");
+    return { target: target3(page.info), applied };
+  });
+}
+async function resizePage(driver, args) {
+  if (!Number.isFinite(args.width) || !Number.isFinite(args.height) || args.width <= 0 || args.height <= 0) {
+    throw new SharedToolError("resize_page requires positive numeric width and height");
+  }
+  return withPage2(driver, args.target, async (page) => {
+    await page.emulate({ width: args.width, height: args.height, deviceScaleFactor: args.deviceScaleFactor, mobile: args.mobile });
+    const v = await page.evaluate("({ w: window.innerWidth, h: window.innerHeight })");
+    return { target: target3(page.info), width: args.width, height: args.height, innerWidth: v?.w ?? args.width, innerHeight: v?.h ?? args.height };
+  });
+}
+async function handleDialog(driver, args) {
+  if (args.accept === undefined)
+    throw new SharedToolError("handle_dialog requires { accept }");
+  return withPage2(driver, args.target, (page) => page.handleDialog(args.accept, args.promptText, { timeoutMs: args.timeoutMs, autoMs: args.autoMs }));
+}
+var SHARED_TOOLS = {
+  list_pages: listPages,
+  new_page: newPage,
+  close_page: closePage,
+  select_page: selectPage,
+  navigate_page: navigatePage,
+  wait_for: waitForText,
+  evaluate_script: evaluateScript,
+  take_snapshot: takeSnapshot,
+  click,
+  hover,
+  drag,
+  fill,
+  fill_form: fillForm,
+  type_text: typeText,
+  press_key: pressKey,
+  upload_file: uploadFile,
+  take_screenshot: takeScreenshot,
+  emulate,
+  resize_page: resizePage,
+  handle_dialog: handleDialog
+};
+
+// src/tools/console.ts
+import { readFile as readFile2 } from "node:fs/promises";
+
+// src/tools/recorder.ts
+import { mkdir as mkdir3, appendFile, writeFile as writeFile3, copyFile } from "node:fs/promises";
+var ARTIFACT_DIR2 = process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
+function recFile(targetId) {
+  return `${ARTIFACT_DIR2}/rec-${targetId}.jsonl`;
+}
+function captureFile(targetId, captureId) {
+  return `${ARTIFACT_DIR2}/rec-${targetId}-${captureId}.jsonl`;
+}
+function delay2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var NETWORK_EVENTS = [
+  "Network.requestWillBeSent",
+  "Network.responseReceived",
+  "Network.loadingFinished",
+  "Network.loadingFailed"
+];
+var CONSOLE_EVENTS = ["Runtime.consoleAPICalled", "Runtime.exceptionThrown", "Log.entryAdded"];
+async function startRecorder(target, opts = {}) {
+  const network = opts.network ?? true;
+  const consoleCap = opts.console ?? true;
+  await mkdir3(ARTIFACT_DIR2, { recursive: true });
+  const { conn, target: resolved } = await openPage(target, { timeoutMs: opts.timeoutMs });
+  const file = opts.file ?? recFile(resolved.id);
+  if (opts.truncate) {
+    await writeFile3(file, "");
+  }
+  let chain = Promise.resolve();
+  let dropped = 0;
+  const persist = (kind, method, params) => {
+    const line = { kind, method, ts: Date.now(), params };
+    const text = `${JSON.stringify(line)}
+`;
+    chain = chain.then(() => appendFile(file, text)).catch(() => {
+      dropped += 1;
+    });
+  };
+  const unsubs = [];
+  try {
+    if (network) {
+      await conn.send("Network.enable");
+      for (const ev of NETWORK_EVENTS) {
+        unsubs.push(conn.on(ev, (params) => persist("network", ev, params)));
+      }
+    }
+    if (consoleCap) {
+      await conn.send("Runtime.enable");
+      try {
+        await conn.send("Log.enable");
+      } catch {}
+      for (const ev of CONSOLE_EVENTS) {
+        unsubs.push(conn.on(ev, (params) => persist("console", ev, params)));
+      }
+    }
+  } catch (err) {
+    conn.close();
+    throw err;
+  }
+  const flush = async () => {
+    for (const off of unsubs)
+      off();
+    await chain;
+  };
+  return {
+    file,
+    target: resolved,
+    conn,
+    droppedWrites: () => dropped,
+    flush,
+    async stop() {
+      await flush();
+      conn.close();
+    }
+  };
+}
+async function captureWindow(target, durationMs, opts = {}) {
+  const resolved = await resolveTarget(target);
+  const captureId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  const file = captureFile(resolved.id, captureId);
+  const rec = await startRecorder(resolved.id, {
+    network: true,
+    console: true,
+    truncate: true,
+    file,
+    timeoutMs: opts.timeoutMs
+  });
+  await rec.conn.send("Page.enable");
+  await rec.conn.send("Page.reload", { ignoreCache: false });
+  await delay2(durationMs);
+  return {
+    file: rec.file,
+    conn: rec.conn,
+    resolved: { id: rec.target.id, url: rec.target.url, title: rec.target.title },
+    droppedWrites: rec.droppedWrites,
+    flush: () => rec.flush(),
+    async stop() {
+      await rec.stop();
+      try {
+        await copyFile(rec.file, recFile(rec.target.id));
+      } catch {}
+    }
+  };
+}
+
+// src/tools/console.ts
+var DEFAULT_CAPTURE_MS = 2500;
+function remoteObjectToText(arg) {
+  if (!arg)
+    return "";
+  if (arg.value !== undefined && arg.value !== null)
+    return String(arg.value);
+  if (typeof arg.description === "string")
+    return arg.description;
+  if (typeof arg.unserializableValue === "string")
+    return arg.unserializableValue;
+  if (arg.type === "undefined")
+    return "undefined";
+  if (arg.type === "object" && arg.subtype === "null")
+    return "null";
+  if (typeof arg.type === "string")
+    return `[${arg.type}]`;
+  return "";
+}
+function lineToEntry(line, index) {
+  const p = line.params;
+  if (line.method === "Runtime.consoleAPICalled") {
+    const args = Array.isArray(p.args) ? p.args : [];
+    return {
+      index,
+      source: "console",
       level: typeof p.type === "string" ? p.type : "log",
       text: args.map(remoteObjectToText).join(" "),
       url: undefined,
@@ -1179,7 +1869,7 @@ function lineToEntry(line, index) {
 async function readConsoleEntries(file) {
   let raw;
   try {
-    raw = await readFile(file, "utf8");
+    raw = await readFile2(file, "utf8");
   } catch {
     return [];
   }
@@ -1235,7 +1925,7 @@ async function getConsoleMessage(args = {}) {
 }
 
 // src/tools/network.ts
-import { readFile as readFile2 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 var DEFAULT_CAPTURE_MS2 = 2500;
 function asHeaders(v) {
   if (!v || typeof v !== "object")
@@ -1302,7 +1992,7 @@ function correlate(lines) {
 async function readNetworkRequests(file) {
   let raw;
   try {
-    raw = await readFile2(file, "utf8");
+    raw = await readFile3(file, "utf8");
   } catch {
     return [];
   }
@@ -1384,8 +2074,8 @@ async function getNetworkRequest(args = {}) {
 }
 
 // src/tools/performance.ts
-import { mkdir as mkdir4, readFile as readFile3, writeFile as writeFile4, stat, unlink } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4, stat, unlink as unlink2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
 var ARTIFACT_DIR3 = process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
 var STATE_DIR2 = process.env.CDP_STATE_DIR ?? "/tmp/cdp-toolkit";
 var DEFAULT_CATEGORIES = [
@@ -1399,11 +2089,11 @@ var liveTraces = new Map;
 function stamp2() {
   return new Date().toISOString().replace(/[:.]/g, "-");
 }
-function shortId2(id) {
+function shortId(id) {
   return id.slice(0, 8);
 }
 function stateFilePath() {
-  return join2(STATE_DIR2, "trace-state.json");
+  return join3(STATE_DIR2, "trace-state.json");
 }
 function bufferTraceData(conn, sink) {
   return conn.on("Tracing.dataCollected", (params) => {
@@ -1426,7 +2116,7 @@ async function endTrace(conn, sink, timeoutMs = 30000) {
 }
 async function writeTrace(events, targetId) {
   await mkdir4(ARTIFACT_DIR3, { recursive: true });
-  const path = join2(ARTIFACT_DIR3, `trace-${shortId2(targetId)}-${stamp2()}.json`);
+  const path = join3(ARTIFACT_DIR3, `trace-${shortId(targetId)}-${stamp2()}.json`);
   const body = JSON.stringify({ traceEvents: events, metadata: { source: "cdp-toolkit" } });
   await writeFile4(path, body, "utf8");
   const { size } = await stat(path);
@@ -1437,7 +2127,7 @@ async function performanceStartTrace(args = {}) {
   const { conn, target } = await openPage(args.target);
   if (liveTraces.has(target.id)) {
     conn.close();
-    throw new CdpError(`a trace is already in progress for target ${shortId2(target.id)}; call performanceStopTrace first`);
+    throw new CdpError(`a trace is already in progress for target ${shortId(target.id)}; call performanceStopTrace first`);
   }
   const events = [];
   bufferTraceData(conn, events);
@@ -1469,9 +2159,9 @@ async function performanceStopTrace(args = {}) {
   if (!entry) {
     let hint = "";
     try {
-      const raw = await readFile3(stateFilePath(), "utf8");
+      const raw = await readFile4(stateFilePath(), "utf8");
       const state = JSON.parse(raw);
-      hint = state.pid === process.pid ? ` (state file lists target ${shortId2(state.targetId)} but its live connection is gone)` : ` (trace was started by a DIFFERENT process pid=${state.pid}; live recordings cannot cross process boundaries)`;
+      hint = state.pid === process.pid ? ` (state file lists target ${shortId(state.targetId)} but its live connection is gone)` : ` (trace was started by a DIFFERENT process pid=${state.pid}; live recordings cannot cross process boundaries)`;
     } catch {}
     throw new CdpError(`no in-process trace to stop${hint}. Use performanceTrace for a robust single-call trace.`);
   }
@@ -1481,7 +2171,7 @@ async function performanceStopTrace(args = {}) {
   } finally {
     conn.close();
     liveTraces.delete(target.id);
-    await unlink(stateFilePath()).catch(() => {});
+    await unlink2(stateFilePath()).catch(() => {});
   }
   const written = await writeTrace(events, target.id);
   const metrics = analyzeEvents(events);
@@ -1599,7 +2289,7 @@ async function performanceAnalyzeInsight(args = {}) {
   }
   let raw;
   try {
-    raw = await readFile3(args.tracePath, "utf8");
+    raw = await readFile4(args.tracePath, "utf8");
   } catch (err) {
     throw new CdpError(`cannot read trace file '${args.tracePath}': ${err.message}`);
   }
@@ -1617,7 +2307,7 @@ async function performanceAnalyzeInsight(args = {}) {
 
 // src/tools/heap.ts
 import { mkdir as mkdir5, writeFile as writeFile5 } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 var ARTIFACT_DIR4 = process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
 function stamp3(targetId) {
   const short = targetId.slice(0, 8);
@@ -1643,7 +2333,7 @@ async function takeHeapsnapshot(args = {}) {
       throw new Error("HeapProfiler.takeHeapSnapshot produced no chunks");
     }
     await mkdir5(ARTIFACT_DIR4, { recursive: true });
-    const path = args.savePath ? args.savePath.startsWith("/") ? args.savePath : join3(ARTIFACT_DIR4, args.savePath) : join3(ARTIFACT_DIR4, `take_heapsnapshot-${stamp3(target.id)}.heapsnapshot`);
+    const path = args.savePath ? args.savePath.startsWith("/") ? args.savePath : join4(ARTIFACT_DIR4, args.savePath) : join4(ARTIFACT_DIR4, `take_heapsnapshot-${stamp3(target.id)}.heapsnapshot`);
     await writeFile5(path, snapshot, "utf8");
     const bytes = Buffer.byteLength(snapshot, "utf8");
     return {
@@ -1657,7 +2347,7 @@ async function takeHeapsnapshot(args = {}) {
 
 // src/tools/lighthouse.ts
 import { spawn } from "node:child_process";
-import { mkdir as mkdir6, readFile as readFile4, stat as stat2 } from "node:fs/promises";
+import { mkdir as mkdir6, readFile as readFile5, stat as stat2 } from "node:fs/promises";
 var ARTIFACT_DIR5 = process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
 function cdpPort() {
   const base = process.env.CDP_BASE ?? "http://127.0.0.1:9222";
@@ -1747,7 +2437,7 @@ async function lighthouseAudit(args) {
   }
   let raw;
   try {
-    raw = await readFile4(outPath, "utf8");
+    raw = await readFile5(outPath, "utf8");
   } catch {
     raw = undefined;
   }
@@ -1755,7 +2445,7 @@ async function lighthouseAudit(args) {
     if (res.signal === "SIGKILL") {
       throw new CdpError(`lighthouse_audit timed out after ${timeoutMs}ms (no report written). stderr: ${truncate(res.stderr)}`);
     }
-    const hint = /not found|could not determine executable|npm ERR|E404|ERR_MODULE/i.test(res.stderr) ? " The Lighthouse CLI could not be fetched/installed via npx — ensure network access and that 'lighthouse' is installable." : "";
+    const hint = /not found|could not determine executable|npm ERR|E404|ERR_MODULE/i.test(res.stderr) ? " The Lighthouse CLI could not be fetched/installed via npx; ensure network access and that 'lighthouse' is installable." : "";
     throw new CdpError(`lighthouse_audit produced no report (exit code ${res.code}).${hint} stderr: ${truncate(res.stderr)}`);
   }
   let report;
@@ -1776,242 +2466,1702 @@ async function lighthouseAudit(args) {
   }
   const { size } = await stat2(outPath);
   return {
-    path: outPath,
-    bytes: size,
-    url,
-    finalUrl: report.finalDisplayedUrl ?? report.finalUrl,
-    lighthouseVersion: report.lighthouseVersion,
-    fetchTime: report.fetchTime,
-    categories,
-    warnings: Array.isArray(report.runWarnings) && report.runWarnings.length > 0 ? report.runWarnings : undefined
+    path: outPath,
+    bytes: size,
+    url,
+    finalUrl: report.finalDisplayedUrl ?? report.finalUrl,
+    lighthouseVersion: report.lighthouseVersion,
+    fetchTime: report.fetchTime,
+    categories,
+    warnings: Array.isArray(report.runWarnings) && report.runWarnings.length > 0 ? report.runWarnings : undefined
+  };
+}
+function truncate(s, max = 600) {
+  const t = s.trim();
+  return t.length > max ? `${t.slice(0, max)}…` : t;
+}
+
+// src/index.ts
+var cdpDriver = createCdpDriver();
+function onCdp(fn) {
+  return (args) => fn(cdpDriver, args);
+}
+var TOOLS = {
+  list_pages: onCdp(SHARED_TOOLS.list_pages),
+  new_page: onCdp(SHARED_TOOLS.new_page),
+  close_page: onCdp(SHARED_TOOLS.close_page),
+  select_page: onCdp(SHARED_TOOLS.select_page),
+  navigate_page: onCdp(SHARED_TOOLS.navigate_page),
+  wait_for: onCdp(SHARED_TOOLS.wait_for),
+  evaluate_script: onCdp(SHARED_TOOLS.evaluate_script),
+  take_snapshot: onCdp(SHARED_TOOLS.take_snapshot),
+  click: onCdp(SHARED_TOOLS.click),
+  hover: onCdp(SHARED_TOOLS.hover),
+  drag: onCdp(SHARED_TOOLS.drag),
+  fill: onCdp(SHARED_TOOLS.fill),
+  fill_form: onCdp(SHARED_TOOLS.fill_form),
+  type_text: onCdp(SHARED_TOOLS.type_text),
+  press_key: onCdp(SHARED_TOOLS.press_key),
+  upload_file: onCdp(SHARED_TOOLS.upload_file),
+  take_screenshot: onCdp(SHARED_TOOLS.take_screenshot),
+  emulate: onCdp(SHARED_TOOLS.emulate),
+  resize_page: onCdp(SHARED_TOOLS.resize_page),
+  handle_dialog: onCdp(SHARED_TOOLS.handle_dialog),
+  list_console_messages: listConsoleMessages,
+  get_console_message: getConsoleMessage,
+  list_network_requests: listNetworkRequests,
+  get_network_request: getNetworkRequest,
+  performance_start_trace: performanceStartTrace,
+  performance_stop_trace: performanceStopTrace,
+  performance_analyze_insight: performanceAnalyzeInsight,
+  performance_trace: performanceTrace,
+  take_heapsnapshot: takeHeapsnapshot,
+  lighthouse_audit: lighthouseAudit,
+  mock_request: mockRequest,
+  list_mocks: listMocks,
+  clear_mocks: clearMocks,
+  claim_page: onCdp(LEASE_TOOLS.claim_page),
+  release_page: onCdp(LEASE_TOOLS.release_page),
+  list_leases: onCdp(LEASE_TOOLS.list_leases)
+};
+var TOOL_NAMES = Object.keys(TOOLS);
+
+// src/bidi/client.ts
+var DEFAULT_TIMEOUT_MS2 = Number(process.env.BIDI_TIMEOUT_MS ?? 15000);
+
+class BidiError extends Error {
+  code;
+  data;
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "BidiError";
+  }
+}
+
+class BidiConnection {
+  wsUrl;
+  opts;
+  ws;
+  nextId = 0;
+  sessId;
+  caps;
+  closed = false;
+  refCount = 0;
+  pending = new Map;
+  listeners = new Map;
+  constructor(wsUrl, opts = {}) {
+    this.wsUrl = wsUrl;
+    this.opts = opts;
+  }
+  get sessionId() {
+    return this.sessId;
+  }
+  get capabilities() {
+    return this.caps;
+  }
+  get holders() {
+    return this.refCount;
+  }
+  connect() {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(this.wsUrl);
+      this.ws = ws;
+      const openTimer = setTimeout(() => reject(new BidiError(`connect timeout: ${this.wsUrl}`)), this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2);
+      ws.onopen = () => {
+        clearTimeout(openTimer);
+        resolve(this);
+      };
+      ws.onerror = (e) => {
+        clearTimeout(openTimer);
+        const msg = e?.message ?? "websocket error";
+        if (this.pending.size === 0)
+          reject(new BidiError(msg));
+        this.rejectAll(new BidiError(msg));
+      };
+      ws.onclose = () => {
+        this.closed = true;
+        this.rejectAll(new BidiError("connection closed"));
+      };
+      ws.onmessage = (ev) => this.onMessage(String(ev.data));
+    });
+  }
+  async newSession(capabilities = {}) {
+    const result = await this.send("session.new", { capabilities });
+    this.sessId = result.sessionId;
+    this.caps = result.capabilities;
+    return result.sessionId;
+  }
+  onMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg.type === "success" || msg.type === "error") {
+      const id = msg.id;
+      if (typeof id !== "number" || !this.pending.has(id))
+        return;
+      const p = this.pending.get(id);
+      clearTimeout(p.timer);
+      this.pending.delete(id);
+      p.resolve(msg);
+      return;
+    }
+    if (msg.type === "event") {
+      const set = this.listeners.get(msg.method);
+      if (set)
+        for (const h of set)
+          h(msg.params);
+    }
+  }
+  rejectAll(err) {
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(err);
+    }
+    this.pending.clear();
+  }
+  send(method, params, opts = {}) {
+    if (this.closed || !this.ws)
+      return Promise.reject(new BidiError("connection not open"));
+    const id = ++this.nextId;
+    const timeoutMs = opts.timeoutMs ?? this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+    const payload = { id, method, params };
+    return new Promise((resolve, reject) => {
+      const start = Date.now();
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        const elapsed = Date.now() - start;
+        reject(new BidiError(`'${method}' timed out after ${elapsed}ms`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        method,
+        start,
+        timer,
+        resolve: (raw) => {
+          if (raw.type === "error")
+            reject(new BidiError(`${method}: ${raw.message}`, raw.error));
+          else
+            resolve(raw.result);
+        },
+        reject
+      });
+      this.ws.send(JSON.stringify(payload));
+    });
+  }
+  on(event, handler) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = new Set;
+      this.listeners.set(event, set);
+    }
+    const first = set.size === 0;
+    set.add(handler);
+    if (first) {
+      this.send("session.subscribe", { events: [event] }).catch(() => {});
+    }
+    let removed = false;
+    return () => {
+      if (removed)
+        return;
+      removed = true;
+      const s = this.listeners.get(event);
+      s?.delete(handler);
+      if (s && s.size === 0) {
+        this.send("session.unsubscribe", { events: [event] }).catch(() => {});
+      }
+    };
+  }
+  waitFor(event, predicate, timeoutMs = this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        off();
+        reject(new BidiError(`waitFor('${event}') timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      const off = this.on(event, (params) => {
+        if (!predicate || predicate(params)) {
+          clearTimeout(timer);
+          off();
+          resolve(params);
+        }
+      });
+    });
+  }
+  retain() {
+    this.refCount++;
+  }
+  release() {
+    if (this.refCount > 0)
+      this.refCount--;
+  }
+  dispose() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    this.rejectAll(new BidiError("connection disposed"));
+    try {
+      this.ws?.close();
+    } catch {}
+  }
+}
+async function connectBidiSession(port, opts = {}) {
+  const conn = new BidiConnection(`ws://127.0.0.1:${port}/session`, { timeoutMs: opts.timeoutMs });
+  await conn.connect();
+  await conn.newSession(opts.capabilities ?? {});
+  conn.retain();
+  return conn;
+}
+
+// src/bidi/snapshot.ts
+var STAMP_ATTR = "data-cdp-uid";
+async function takeStampedSnapshot(evaluate) {
+  const raw = await evaluate(buildSnapshotFunctionSource());
+  return coerceSnapshotResult(raw);
+}
+function coerceSnapshotResult(raw) {
+  if (typeof raw !== "object" || raw === null || typeof raw.snapshot !== "string" || typeof raw.nodeCount !== "number") {
+    throw new Error("takeStampedSnapshot: evaluate() returned an unexpected shape");
+  }
+  return { snapshot: raw.snapshot, nodeCount: raw.nodeCount };
+}
+function buildSnapshotFunctionSource() {
+  return `function() {
+    var STAMP_ATTR = ${JSON.stringify(STAMP_ATTR)};
+    var MAX_NAME_LENGTH = ${MAX_NAME_LENGTH};
+    var lines = [];
+    var nodeCount = 0;
+
+    // THE UID CODEC (driver.ts) documents a bidi payload as exactly 12 lowercase hex chars,
+    // /^[0-9a-f]{12}$/. Build it from two padded random blocks so the length is exact regardless
+    // of the random value drawn, never from string concatenation that could come up short.
+    function nextStamp() {
+      var hi = Math.floor(Math.random() * 0x100000000).toString(16).padStart(8, "0");
+      var lo = Math.floor(Math.random() * 0x10000).toString(16).padStart(4, "0");
+      return hi + lo;
+    }
+
+    function stampOf(el) {
+      var existing = el.getAttribute(STAMP_ATTR);
+      if (existing) return existing;
+      var stamp = nextStamp();
+      el.setAttribute(STAMP_ATTR, stamp);
+      return stamp;
+    }
+
+    // skipSizeCheck exempts <option>/<optgroup> from the zero-size prune: a
+    // closed select's popup is unpainted (0x0) though its options are still
+    // present and pickable. Other visibility rules still apply to them.
+    function isVisible(el, skipSizeCheck) {
+      if (el.hidden) return false;
+      if (el.getAttribute("aria-hidden") === "true") return false;
+      var style;
+      try {
+        style = el.ownerDocument.defaultView.getComputedStyle(el);
+      } catch (e) {
+        style = null;
+      }
+      if (style) {
+        if (style.display === "none" || style.visibility === "hidden") return false;
+      }
+      if (!skipSizeCheck) {
+        var rect = el.getBoundingClientRect();
+        if (rect.width === 0 && rect.height === 0) return false;
+      }
+      return true;
+    }
+
+    function truncate(s) {
+      s = s.trim().replace(/\\s+/g, " ");
+      if (s.length > MAX_NAME_LENGTH) return s.slice(0, MAX_NAME_LENGTH - 1) + "\\u2026";
+      return s;
+    }
+
+    function textOf(el) {
+      return el.textContent || "";
+    }
+
+    function idRefsText(doc, ids) {
+      var parts = [];
+      var list = ids.trim().split(/\\s+/);
+      for (var i = 0; i < list.length; i++) {
+        var ref = doc.getElementById(list[i]);
+        if (ref) parts.push(textOf(ref));
+      }
+      return parts.join(" ").trim();
+    }
+
+    // Text of a <label>, minus any nested form control's own content: a
+    // label that WRAPS its control ("<label>Color <select>...</select></label>")
+    // would otherwise include every option's text in the control's own name.
+    function labelOwnText(label) {
+      var clone = label.cloneNode(true);
+      var controls = clone.querySelectorAll("input, select, textarea, button");
+      for (var i = 0; i < controls.length; i++) {
+        controls[i].parentNode.removeChild(controls[i]);
+      }
+      return textOf(clone);
+    }
+
+    // Guard: without this, an <option> inside a labelled <select> would
+    // inherit the select's own label via closest("label"), not its text.
+    var LABELABLE_TAGS = { INPUT: 1, TEXTAREA: 1, SELECT: 1, BUTTON: 1, METER: 1, OUTPUT: 1, PROGRESS: 1 };
+
+    function nativeLabelText(el) {
+      if (!LABELABLE_TAGS[el.tagName]) return "";
+      var doc = el.ownerDocument;
+      if (el.id) {
+        var forLabel = doc.querySelector('label[for="' + el.id + '"]');
+        if (forLabel) return labelOwnText(forLabel);
+      }
+      var ancestor = el.closest ? el.closest("label") : null;
+      if (ancestor) return labelOwnText(ancestor);
+      return "";
+    }
+
+    // Reduced accname: aria-labelledby, then aria-label, then native label,
+    // then alt/title/placeholder, then trimmed own text for content-named
+    // elements. Not the full W3C accname algorithm (no recursive traversal
+    // rules for nested presentational content) but covers the common cases.
+    function accessibleName(el, contentNamed) {
+      var doc = el.ownerDocument;
+      var labelledby = el.getAttribute("aria-labelledby");
+      if (labelledby) {
+        var viaIds = idRefsText(doc, labelledby);
+        if (viaIds) return truncate(viaIds);
+      }
+      var ariaLabel = el.getAttribute("aria-label");
+      if (ariaLabel && ariaLabel.trim()) return truncate(ariaLabel);
+      var native = nativeLabelText(el);
+      if (native && native.trim()) return truncate(native);
+      var alt = el.getAttribute("alt");
+      if (alt && alt.trim()) return truncate(alt);
+      var title = el.getAttribute("title");
+      if (title && title.trim()) return truncate(title);
+      var placeholder = el.getAttribute("placeholder");
+      if (placeholder && placeholder.trim()) return truncate(placeholder);
+      if (contentNamed) {
+        var text = textOf(el);
+        if (text && text.trim()) return truncate(text);
+      }
+      return "";
+    }
+
+    var IMPLICIT_ROLE_BY_TAG = {
+      A: "link", BUTTON: "button", NAV: "navigation", MAIN: "main", FORM: "form", DIALOG: "dialog",
+      UL: "list", OL: "list", LI: "listitem", TABLE: "table", TR: "row", TD: "cell", TH: "columnheader",
+      SELECT: "combobox", OPTION: "option", TEXTAREA: "textbox", IMG: "img",
+      H1: "heading", H2: "heading", H3: "heading", H4: "heading", H5: "heading", H6: "heading",
+      PROGRESS: "progressbar", METER: "meter"
+    };
+
+    var INPUT_TYPE_ROLE = {
+      button: "button", submit: "button", reset: "button", checkbox: "checkbox", radio: "radio",
+      range: "slider", number: "spinbutton", search: "searchbox", email: "textbox", tel: "textbox",
+      url: "textbox", password: "textbox", text: "textbox", image: "button"
+    };
+
+    var CONTENT_NAMED_ROLES = {
+      button: true, link: true, heading: true, option: true, cell: true,
+      columnheader: true, listitem: true, menuitem: true, tab: true
+    };
+
+    function implicitRole(el) {
+      var explicit = el.getAttribute("role");
+      if (explicit) return explicit;
+      var tag = el.tagName;
+      if (tag === "INPUT") {
+        var type = (el.getAttribute("type") || "text").toLowerCase();
+        return INPUT_TYPE_ROLE[type] || "textbox";
+      }
+      if (tag === "A" && !el.getAttribute("href")) return "";
+      if (Object.prototype.hasOwnProperty.call(IMPLICIT_ROLE_BY_TAG, tag)) {
+        return IMPLICIT_ROLE_BY_TAG[tag];
+      }
+      // Deliberate divergence: Chrome's real AX tree says "generic" here,
+      // but "textbox" is the useful signal an agent needs. Chrome is out of
+      // step, do not "fix" this toward parity.
+      if (el.isContentEditable) return "textbox";
+      return "";
+    }
+
+    function headingLevel(el) {
+      var m = /^H([1-6])$/.exec(el.tagName);
+      return m ? m[1] : null;
+    }
+
+    function currentValue(el) {
+      var tag = el.tagName;
+      if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") {
+        return el.value;
+      }
+      if (el.isContentEditable) return textOf(el);
+      return undefined;
+    }
+
+    function isChecked(el) {
+      var tag = el.tagName;
+      if (tag === "INPUT") {
+        var type = (el.getAttribute("type") || "").toLowerCase();
+        if (type === "checkbox" || type === "radio") return !!el.checked;
+      }
+      var aria = el.getAttribute("aria-checked");
+      if (aria === "true") return true;
+      return false;
+    }
+
+    function describeNode(el, role) {
+      var contentNamed = !!CONTENT_NAMED_ROLES[role];
+      var name = accessibleName(el, contentNamed);
+      var extras = [];
+      var value = currentValue(el);
+      if (value !== undefined && value !== "") extras.push("value=" + JSON.stringify(String(value)));
+      if (isChecked(el)) extras.push("checked=true");
+      if (el.tagName === "OPTION" && el.selected) extras.push("selected");
+      var href = el.getAttribute("href");
+      if (href) extras.push("url=" + href);
+      if (el.disabled || el.getAttribute("aria-disabled") === "true") extras.push("disabled");
+      var level = headingLevel(el);
+      if (level) extras.push("level=" + level);
+      var label = name ? " " + JSON.stringify(name) : "";
+      var extra = extras.length ? " [" + extras.join(" ") + "]" : "";
+      return { role: role, label: label, extra: extra, name: name };
+    }
+
+    // Traverses light DOM, open shadow roots, and same-origin iframe documents.
+    // A cross-origin iframe throws on contentDocument access; caught and
+    // skipped rather than aborting the whole walk, and noted in a comment
+    // here rather than silently vanishing from the tree without a trace.
+    function walk(root, depth) {
+      var children = root.children ? Array.prototype.slice.call(root.children) : [];
+      for (var i = 0; i < children.length; i++) {
+        var el = children[i];
+        var isSelectChild = el.tagName === "OPTION" || el.tagName === "OPTGROUP";
+        if (!isVisible(el, isSelectChild)) continue;
+
+        var role = implicitRole(el);
+        var isLandmarkOrControl = !!role;
+        var described = null;
+        if (isLandmarkOrControl) {
+          described = describeNode(el, role);
+        }
+
+        var hasContent = described && (described.name || described.extra);
+        var isStructural = isLandmarkOrControl && (hasContent || isInteractiveRole(role) || isLandmarkRole(role));
+
+        // Role-less visible leaf text (measured vs Chrome's take_snapshot,
+        // which keeps a StaticText under a generic wrapper for this case,
+        // e.g. a plain status <div>). Only a leaf (no element children, so
+        // its text is not already captured by a nested control/label).
+        var hasElementChildren = !!(el.children && el.children.length > 0);
+        var leafName = !isStructural && !hasElementChildren ? truncate(textOf(el)) : "";
+        var isLeafText = !!leafName;
+
+        var nextDepth = depth;
+        if (isStructural || isLeafText) {
+          var stamp = stampOf(el);
+          var indent = new Array(depth + 1).join("  ");
+          var lineTail = isStructural
+            ? described.role + described.label + described.extra
+            : "text " + JSON.stringify(leafName);
+          lines.push(indent + "[" + stamp + "] " + lineTail);
+          nodeCount += 1;
+          nextDepth = depth + 1;
+        }
+
+        if (el.shadowRoot) {
+          walk(el.shadowRoot, nextDepth);
+        } else if (el.tagName === "IFRAME") {
+          try {
+            var doc = el.contentDocument;
+            if (doc && doc.body) walk(doc.body, nextDepth);
+          } catch (e) {
+            // cross-origin iframe: intentionally skipped, not silently merged
+            // into the parent tree as though it were empty.
+          }
+        } else {
+          walk(el, nextDepth);
+        }
+      }
+    }
+
+    function isInteractiveRole(role) {
+      return (
+        role === "button" ||
+        role === "link" ||
+        role === "textbox" ||
+        role === "searchbox" ||
+        role === "checkbox" ||
+        role === "radio" ||
+        role === "combobox" ||
+        role === "listbox" ||
+        role === "option" ||
+        role === "slider" ||
+        role === "spinbutton" ||
+        role === "progressbar" ||
+        role === "meter"
+      );
+    }
+
+    function isLandmarkRole(role) {
+      return (
+        role === "navigation" ||
+        role === "main" ||
+        role === "form" ||
+        role === "dialog" ||
+        role === "region" ||
+        role === "heading" ||
+        role === "list" ||
+        role === "listitem" ||
+        role === "table" ||
+        role === "row" ||
+        role === "cell" ||
+        role === "columnheader" ||
+        role === "img"
+      );
+    }
+
+    walk(document.body, 0);
+    return { snapshot: lines.join("\\n"), nodeCount: nodeCount };
+  }`;
+}
+var MAX_NAME_LENGTH = 120;
+
+// src/bidi/driver.ts
+function driverError2(code, message, data) {
+  return Object.assign(new Error(message), { code, ...data !== undefined ? { data } : {} });
+}
+function encodeUid2(stamp5) {
+  return `bidi:${stamp5}`;
+}
+function decodeStamp(uid) {
+  if (!uid.startsWith("bidi:"))
+    throw driverError2("foreign-uid", `uid is not owned by the bidi driver: ${uid}`);
+  const payload = uid.slice(5);
+  if (!payload.length)
+    throw driverError2("foreign-uid", `malformed bidi uid payload: ${uid}`);
+  return payload;
+}
+function cssEscape(s) {
+  return s.replace(/["\\]/g, (c) => `\\${c}`);
+}
+function mapBidiError(e) {
+  if (e instanceof BidiError) {
+    const code = e.code;
+    if (code === "no such node" || code === "no such element")
+      return driverError2("no-such-element", e.message);
+    if (code === "no such frame")
+      return driverError2("no-such-target", e.message);
+    if (code === "invalid session id")
+      return driverError2("disconnected", e.message);
+    if (code === "unsupported operation")
+      return driverError2("unsupported", e.message);
+    if (!code && /timed out/i.test(e.message))
+      return driverError2("timeout", e.message);
+    if (!code && /(disposed|not open|connection closed)/i.test(e.message))
+      return driverError2("disconnected", e.message);
+    return driverError2("page-error", e.message);
+  }
+  return driverError2("page-error", e instanceof Error ? e.message : String(e));
+}
+function serializeArg(v) {
+  if (v === undefined)
+    return { type: "undefined" };
+  if (v === null)
+    return { type: "null" };
+  if (typeof v === "string")
+    return { type: "string", value: v };
+  if (typeof v === "number")
+    return { type: "number", value: Number.isNaN(v) ? "NaN" : v };
+  if (typeof v === "boolean")
+    return { type: "boolean", value: v };
+  if (Array.isArray(v))
+    return { type: "array", value: v.map(serializeArg) };
+  if (typeof v === "object")
+    return { type: "object", value: Object.entries(v).map(([k, val]) => [k, serializeArg(val)]) };
+  return { type: "string", value: String(v) };
+}
+function deserializeRemote(rv) {
+  switch (rv.type) {
+    case "undefined":
+      return;
+    case "null":
+      return null;
+    case "string":
+      return rv.value;
+    case "boolean":
+      return rv.value;
+    case "bigint":
+      return rv.value;
+    case "number":
+      return typeof rv.value === "number" ? rv.value : rv.value;
+    case "array":
+      return (rv.value ?? []).map(deserializeRemote);
+    case "object": {
+      const out = {};
+      for (const [k, v] of rv.value ?? [])
+        out[typeof k === "string" ? k : String(deserializeRemote(k))] = deserializeRemote(v);
+      return out;
+    }
+    case "node":
+      return { bidiSharedId: rv.sharedId };
+    default:
+      return;
+  }
+}
+function exceptionMessage2(d) {
+  if (d.text)
+    return d.text;
+  const ex = deserializeRemote(d.exception);
+  return typeof ex === "string" ? ex : "evaluation threw";
+}
+var LINE_RE = /^((?: {2})*)\[([0-9a-f]+)\] ([a-zA-Z_][\w-]*)(?: ("(?:[^"\\]|\\.)*"))?(?: \[(.*)\])?$/;
+function splitExtras(s) {
+  const out = [];
+  let cur = "";
+  let inQuotes = false;
+  for (let i = 0;i < s.length; i++) {
+    const ch = s[i];
+    if (ch === '"' && s[i - 1] !== "\\")
+      inQuotes = !inQuotes;
+    if (ch === " " && !inQuotes) {
+      if (cur)
+        out.push(cur);
+      cur = "";
+    } else
+      cur += ch;
+  }
+  if (cur)
+    out.push(cur);
+  return out;
+}
+function parseSnapshotLine(line) {
+  const m = LINE_RE.exec(line);
+  if (!m)
+    return;
+  const indent = m[1] ?? "", stamp5 = m[2], role = m[3], nameLit = m[4], extrasRaw = m[5];
+  const depth = indent.length / 2;
+  let name;
+  if (nameLit) {
+    try {
+      name = JSON.parse(nameLit);
+    } catch {
+      name = nameLit;
+    }
+  }
+  const extras = {};
+  if (extrasRaw) {
+    for (const tok of splitExtras(extrasRaw)) {
+      const eq = tok.indexOf("=");
+      if (eq === -1) {
+        extras[tok] = "true";
+        continue;
+      }
+      const key = tok.slice(0, eq);
+      let val = tok.slice(eq + 1);
+      if (val.startsWith('"')) {
+        try {
+          val = JSON.parse(val);
+        } catch {}
+      }
+      extras[key] = val;
+    }
+  }
+  return { uid: encodeUid2(stamp5), role, depth, ...name !== undefined ? { name } : {}, ...Object.keys(extras).length ? { extras } : {} };
+}
+var INTERACTIVE_ROLES3 = new Set([
+  "button",
+  "link",
+  "textbox",
+  "searchbox",
+  "checkbox",
+  "radio",
+  "combobox",
+  "listbox",
+  "option",
+  "slider",
+  "spinbutton",
+  "progressbar",
+  "meter"
+]);
+var STAMP_ONE_SOURCE = `function(){var a=${JSON.stringify(UID_STAMP_ATTR)};var e=this.getAttribute(a);if(e)return e;var s=Math.floor(Math.random()*0x100000000).toString(16).padStart(8,"0")+Math.floor(Math.random()*0x10000).toString(16).padStart(4,"0");this.setAttribute(a,s);return s;}`;
+async function locateNodes(conn, contextId, locator) {
+  try {
+    const { nodes } = await conn.send("browsingContext.locateNodes", { context: contextId, locator, maxNodeCount: 1 });
+    return nodes;
+  } catch (e) {
+    throw mapBidiError(e);
+  }
+}
+function sharedRefOf(node, describe) {
+  if (!node.sharedId)
+    throw driverError2("page-error", `located node has no sharedId (${describe})`);
+  return { sharedId: node.sharedId };
+}
+async function resolveElementLocator2(conn, contextId, loc) {
+  if ("uid" in loc) {
+    const stamp5 = decodeStamp(loc.uid);
+    const nodes2 = await locateNodes(conn, contextId, { type: "css", value: `[${UID_STAMP_ATTR}="${cssEscape(stamp5)}"]` });
+    if (!nodes2.length)
+      throw driverError2("stale-uid", `uid does not resolve: ${loc.uid}`);
+    return sharedRefOf(nodes2[0], loc.uid);
+  }
+  if ("css" in loc) {
+    const nodes2 = await locateNodes(conn, contextId, { type: "css", value: loc.css });
+    if (!nodes2.length)
+      throw driverError2("no-such-element", `css '${loc.css}' matched no element`);
+    return sharedRefOf(nodes2[0], `css '${loc.css}'`);
+  }
+  if ("xpath" in loc) {
+    const nodes2 = await locateNodes(conn, contextId, { type: "xpath", value: loc.xpath });
+    if (!nodes2.length)
+      throw driverError2("no-such-element", `xpath '${loc.xpath}' matched no element`);
+    return sharedRefOf(nodes2[0], `xpath '${loc.xpath}'`);
+  }
+  const nodes = await locateNodes(conn, contextId, { type: "innerText", value: loc.text, matchType: "partial" });
+  if (!nodes.length)
+    throw driverError2("no-such-element", `text '${loc.text}' matched no element`);
+  return sharedRefOf(nodes[0], `text '${loc.text}'`);
+}
+var KEY_VALUES = {
+  enter: "",
+  return: "",
+  tab: "",
+  escape: "",
+  esc: "",
+  backspace: "",
+  delete: "",
+  space: " ",
+  arrowup: "",
+  arrowdown: "",
+  arrowleft: "",
+  arrowright: "",
+  up: "",
+  down: "",
+  left: "",
+  right: "",
+  home: "",
+  end: "",
+  pageup: "",
+  pagedown: ""
+};
+var MODIFIER_VALUES = { shift: "", control: "", ctrl: "", alt: "", meta: "", cmd: "", command: "" };
+var BUTTON_CODES = { left: 0, middle: 1, right: 2 };
+var BIDI_CAPABILITIES = new Set([
+  "emulate.deviceMetrics",
+  "screenshot.fullPage",
+  "screenshot.element",
+  "network.intercept",
+  "locate.xpath"
+]);
+var connections = new Map;
+async function getConnection(port, timeoutMs) {
+  const existing = connections.get(port);
+  if (existing) {
+    existing.retain();
+    return existing;
+  }
+  const conn = await connectBidiSession(port, {
+    ...timeoutMs !== undefined ? { timeoutMs } : {},
+    capabilities: { alwaysMatch: { unhandledPromptBehavior: { default: "ignore" } } }
+  });
+  connections.set(port, conn);
+  return conn;
+}
+async function safeTitle(conn, contextId) {
+  try {
+    const res = await conn.send("script.evaluate", { expression: "document.title", target: { context: contextId }, awaitPromise: false });
+    return res.type === "success" && res.result.type === "string" ? res.result.value : "";
+  } catch {
+    return "";
+  }
+}
+async function pageInfoOf(conn, ctx) {
+  return { id: ctx.context, url: ctx.url, title: await safeTitle(conn, ctx.context) };
+}
+async function resolveContext(conn, selector, opts = {}) {
+  const { contexts } = await conn.send("browsingContext.getTree", {}).catch((e) => {
+    throw mapBidiError(e);
+  });
+  if (!contexts.length)
+    throw driverError2("no-such-target", "no browsing contexts available");
+  const hit = await pickContext(conn, contexts, selector);
+  await assertLeaseOk("firefox", hit.context, { lease: opts.lease, url: hit.url });
+  return hit;
+}
+async function pickContext(conn, contexts, selector) {
+  if (selector === undefined || selector === "active")
+    return contexts[0];
+  if (selector.startsWith("index:")) {
+    const t = contexts[Number(selector.slice(6))];
+    if (!t)
+      throw driverError2("no-such-target", `no context at ${selector}`);
+    return t;
+  }
+  if (selector.startsWith("url:")) {
+    const needle = selector.slice(4);
+    const t = contexts.find((c) => c.url.includes(needle));
+    if (!t)
+      throw driverError2("no-such-target", `no context with url containing '${needle}'`);
+    return t;
+  }
+  if (selector.startsWith("title:")) {
+    const needle = selector.slice(6);
+    for (const c of contexts)
+      if ((await safeTitle(conn, c.context)).includes(needle))
+        return c;
+    throw driverError2("no-such-target", `no context with title containing '${needle}'`);
+  }
+  const exact = contexts.find((c) => c.context === selector);
+  if (exact)
+    return exact;
+  throw driverError2("no-such-target", `no context matching '${selector}'`);
+}
+
+class BidiPageDriver {
+  conn;
+  contextId;
+  info;
+  browser;
+  released = false;
+  bodyCollector;
+  constructor(conn, contextId, info, browser) {
+    this.conn = conn;
+    this.contextId = contextId;
+    this.info = info;
+    this.browser = browser;
+  }
+  async navigate(opts) {
+    const reload = opts.reload === true;
+    if (!reload && !opts.url)
+      throw driverError2("page-error", "navigate: 'url' is required unless reload:true");
+    const waitUntil = opts.waitUntil ?? "load";
+    const wait = waitUntil === "domcontentloaded" ? "interactive" : "complete";
+    const sendOpts = opts.timeoutMs !== undefined ? { timeoutMs: opts.timeoutMs } : {};
+    try {
+      if (reload) {
+        const r2 = await this.conn.send("browsingContext.reload", { context: this.contextId, ignoreCache: opts.ignoreCache === true, wait }, sendOpts);
+        return { url: r2.url, contextId: this.contextId, reloaded: true, waitedFor: waitUntil };
+      }
+      const r = await this.conn.send("browsingContext.navigate", { context: this.contextId, url: opts.url, wait }, sendOpts);
+      return { url: r.url, contextId: this.contextId, waitedFor: waitUntil };
+    } catch (e) {
+      throw mapBidiError(e);
+    }
+  }
+  async waitForText(text, timeoutMs = 15000, pollMs = 250) {
+    const start = Date.now();
+    const expr = `(() => { const b = document.body; return !!b && typeof b.innerText === 'string' && b.innerText.includes(${JSON.stringify(text)}); })()`;
+    for (;; ) {
+      const found = await this.conn.send("script.evaluate", { expression: expr, target: { context: this.contextId }, awaitPromise: true }).then((r) => r.type === "success" && deserializeRemote(r.result) === true).catch(() => false);
+      if (found)
+        return { found: true, elapsedMs: Date.now() - start };
+      if (Date.now() - start >= timeoutMs)
+        throw driverError2("timeout", `waitForText: '${text}' not found within ${timeoutMs}ms`);
+      await new Promise((r) => setTimeout(r, Math.min(pollMs, Math.max(0, timeoutMs - (Date.now() - start)))));
+    }
+  }
+  async callFunctionValue(functionDeclaration, args, thisRef) {
+    try {
+      const res = await this.conn.send("script.callFunction", {
+        functionDeclaration,
+        awaitPromise: true,
+        target: { context: this.contextId },
+        arguments: args.map(serializeArg),
+        ...thisRef ? { this: thisRef } : {}
+      });
+      if (res.type === "exception")
+        throw driverError2("page-error", exceptionMessage2(res.exceptionDetails));
+      return deserializeRemote(res.result);
+    } catch (e) {
+      throw isDriverError(e) ? e : mapBidiError(e);
+    }
+  }
+  async evaluate(expression, opts) {
+    const awaitPromise = opts?.awaitPromise ?? true;
+    if (opts?.args && opts.args.length > 0)
+      return this.callFunctionValue(expression, [...opts.args]);
+    try {
+      const res = await this.conn.send("script.evaluate", { expression, awaitPromise, target: { context: this.contextId } });
+      if (res.type === "exception")
+        throw driverError2("page-error", exceptionMessage2(res.exceptionDetails));
+      return deserializeRemote(res.result);
+    } catch (e) {
+      throw isDriverError(e) ? e : mapBidiError(e);
+    }
+  }
+  async callOnElement(loc, functionDeclaration, args = []) {
+    const ref = await resolveElementLocator2(this.conn, this.contextId, loc);
+    return this.callFunctionValue(functionDeclaration, [...args], ref);
+  }
+  async snapshot(opts) {
+    const { snapshot } = await takeStampedSnapshot((src) => this.callFunctionValue(src, []));
+    const nodes = [];
+    for (const line of snapshot.split(`
+`)) {
+      if (!line)
+        continue;
+      const n = parseSnapshotLine(line);
+      if (n)
+        nodes.push(n);
+    }
+    return opts?.interactiveOnly ? nodes.filter((n) => INTERACTIVE_ROLES3.has(n.role)) : nodes;
+  }
+  async locate(loc) {
+    if ("uid" in loc) {
+      await this.resolve(loc.uid);
+      return loc.uid;
+    }
+    const ref = await resolveElementLocator2(this.conn, this.contextId, loc);
+    const stamp5 = await this.callFunctionValue(STAMP_ONE_SOURCE, [], ref);
+    if (typeof stamp5 !== "string")
+      throw driverError2("page-error", "stamping the located element did not return a string");
+    return encodeUid2(stamp5);
+  }
+  async resolve(uid) {
+    const stamp5 = decodeStamp(uid);
+    const nodes = await locateNodes(this.conn, this.contextId, { type: "css", value: `[${UID_STAMP_ATTR}="${cssEscape(stamp5)}"]` });
+    if (!nodes.length)
+      throw driverError2("stale-uid", `uid does not resolve: ${uid}`);
+  }
+  async performActions(actions) {
+    try {
+      await this.conn.send("input.performActions", { context: this.contextId, actions });
+    } catch (e) {
+      throw mapBidiError(e);
+    }
+  }
+  async centerOf(ref) {
+    const fn = "function(){this.scrollIntoView({block:'center',inline:'center'});const r=this.getBoundingClientRect();if(r.width===0&&r.height===0)return null;return {x:r.left+r.width/2,y:r.top+r.height/2};}";
+    const val = await this.callFunctionValue(fn, [], ref);
+    if (!val || typeof val !== "object")
+      throw driverError2("page-error", "element has zero size / is not visible; cannot compute a click point");
+    return val;
+  }
+  async hover(loc) {
+    const ref = await resolveElementLocator2(this.conn, this.contextId, loc);
+    const { x, y } = await this.centerOf(ref);
+    await this.performActions([{ type: "pointer", id: "cdp-mouse", actions: [{ type: "pointerMove", x, y, duration: 0 }] }]);
+    return { x, y };
+  }
+  async click(loc, opts) {
+    const ref = await resolveElementLocator2(this.conn, this.contextId, loc);
+    const { x, y } = await this.centerOf(ref);
+    const button = BUTTON_CODES[opts?.button ?? "left"];
+    const actions = [{ type: "pointerMove", x, y, duration: 0 }];
+    for (let i = 0;i < (opts?.clickCount ?? 1); i++)
+      actions.push({ type: "pointerDown", button }, { type: "pointerUp", button });
+    await this.performActions([{ type: "pointer", id: "cdp-mouse", actions }]);
+    return { x, y };
+  }
+  async drag(from, to) {
+    const fromPt = await this.centerOf(await resolveElementLocator2(this.conn, this.contextId, from));
+    const toPt = await this.centerOf(await resolveElementLocator2(this.conn, this.contextId, to));
+    const actions = [
+      { type: "pointerMove", x: fromPt.x, y: fromPt.y, duration: 0 },
+      { type: "pointerDown", button: 0 },
+      { type: "pointerMove", x: (fromPt.x + toPt.x) / 2, y: (fromPt.y + toPt.y) / 2, duration: 50 },
+      { type: "pointerMove", x: toPt.x, y: toPt.y, duration: 50 },
+      { type: "pointerUp", button: 0 }
+    ];
+    await this.performActions([{ type: "pointer", id: "cdp-mouse", actions }]);
+    return { from: fromPt, to: toPt };
+  }
+  async sendKeys(text) {
+    if (!text.length)
+      return;
+    const actions = [];
+    for (const ch of text)
+      actions.push({ type: "keyDown", value: ch }, { type: "keyUp", value: ch });
+    await this.performActions([{ type: "key", id: "cdp-keyboard", actions }]);
+  }
+  static SELECT_SOURCE = "function(v){var found=false;for(var i=0;i<this.options.length;i++){if(this.options[i].value===v){this.selectedIndex=i;found=true;break;}}if(!found)this.value=v;this.dispatchEvent(new Event('input',{bubbles:true}));this.dispatchEvent(new Event('change',{bubbles:true}));}";
+  static INSERT_TEXT_SOURCE = "function(v,collapseAtEnd){this.focus();var r=document.createRange();" + "r.selectNodeContents(this);if(collapseAtEnd)r.collapse(false);" + "var s=window.getSelection();s.removeAllRanges();s.addRange(r);" + "return document.execCommand('insertText', false, v);}";
+  static IS_CONTENT_EDITABLE = "function(){return this.isContentEditable===true;}";
+  async setValue(loc, value) {
+    const ref = await resolveElementLocator2(this.conn, this.contextId, loc);
+    const isSelect = await this.callFunctionValue("function(){return this.tagName==='SELECT';}", [], ref);
+    if (isSelect === true) {
+      await this.callFunctionValue(BidiPageDriver.SELECT_SOURCE, [value], ref);
+      return;
+    }
+    const isContentEditable = await this.callFunctionValue(BidiPageDriver.IS_CONTENT_EDITABLE, [], ref);
+    if (isContentEditable === true) {
+      await this.callFunctionValue(BidiPageDriver.INSERT_TEXT_SOURCE, [value, false], ref);
+      return;
+    }
+    const clear = "function(){this.focus&&this.focus();if('value' in this){this.value='';this.dispatchEvent(new Event('input',{bubbles:true}));}}";
+    await this.callFunctionValue(clear, [], ref);
+    await this.sendKeys(value);
+  }
+  async typeText(loc, text) {
+    const ref = await resolveElementLocator2(this.conn, this.contextId, loc);
+    const isContentEditable = await this.callFunctionValue(BidiPageDriver.IS_CONTENT_EDITABLE, [], ref);
+    if (isContentEditable === true) {
+      await this.callFunctionValue(BidiPageDriver.INSERT_TEXT_SOURCE, [text, true], ref);
+      return;
+    }
+    await this.callFunctionValue("function(){this.focus&&this.focus();}", [], ref);
+    await this.sendKeys(text);
+  }
+  async pressKey(press) {
+    const value = KEY_VALUES[press.key.toLowerCase()] ?? (press.key.length === 1 ? press.key : undefined);
+    if (value === undefined)
+      throw driverError2("page-error", `unknown key '${press.key}' (use a named key like Enter/Tab/ArrowDown or a single character)`);
+    const mods = [];
+    for (const m of press.modifiers ?? []) {
+      const v = MODIFIER_VALUES[m.toLowerCase()];
+      if (v === undefined)
+        throw driverError2("page-error", `unknown modifier '${m}'`);
+      mods.push(v);
+    }
+    const actions = [...mods.map((v) => ({ type: "keyDown", value: v })), { type: "keyDown", value }, { type: "keyUp", value }, ...[...mods].reverse().map((v) => ({ type: "keyUp", value: v }))];
+    await this.performActions([{ type: "key", id: "cdp-keyboard", actions }]);
+  }
+  async setFiles(loc, files) {
+    const ref = await resolveElementLocator2(this.conn, this.contextId, loc);
+    try {
+      await this.conn.send("input.setFiles", { context: this.contextId, element: ref, files: [...files] });
+    } catch (e) {
+      throw mapBidiError(e);
+    }
+  }
+  async screenshot(opts) {
+    const format = opts?.format ?? "png";
+    const params = {
+      context: this.contextId,
+      format: { type: format === "jpeg" ? "image/jpeg" : "image/png", ...format === "jpeg" ? { quality: (opts?.quality ?? 80) / 100 } : {} }
+    };
+    if (opts?.clip)
+      params.clip = { type: "element", element: await resolveElementLocator2(this.conn, this.contextId, opts.clip) };
+    else if (opts?.fullPage)
+      params.origin = "document";
+    try {
+      const { data } = await this.conn.send("browsingContext.captureScreenshot", params);
+      return { data: new Uint8Array(Buffer.from(data, "base64")), format };
+    } catch (e) {
+      throw mapBidiError(e);
+    }
+  }
+  async emulate(opts) {
+    if (opts.clearOverrides) {
+      await this.conn.send("emulation.setUserAgentOverride", { userAgent: null, contexts: [this.contextId] }).catch(() => {
+        return;
+      });
+      await this.conn.send("browsingContext.setViewport", { context: this.contextId, viewport: null, devicePixelRatio: null }).catch(() => {
+        return;
+      });
+      return { applied: [] };
+    }
+    const applied = [];
+    try {
+      if (opts.width != null && opts.height != null) {
+        await this.conn.send("browsingContext.setViewport", { context: this.contextId, viewport: { width: opts.width, height: opts.height }, ...opts.deviceScaleFactor != null ? { devicePixelRatio: opts.deviceScaleFactor } : {} });
+        applied.push("deviceMetrics");
+      }
+      if (opts.userAgent != null) {
+        await this.conn.send("emulation.setUserAgentOverride", { userAgent: opts.userAgent, contexts: [this.contextId] });
+        applied.push("userAgent");
+      }
+    } catch (e) {
+      throw mapBidiError(e);
+    }
+    return { applied };
+  }
+  static EVENT_MAP = {
+    navigated: "browsingContext.navigationCommitted",
+    console: "log.entryAdded",
+    "network.request": "network.beforeRequestSent",
+    "network.response": "network.responseCompleted",
+    dialog: "browsingContext.userPromptOpened",
+    "page.closed": "browsingContext.contextDestroyed"
+  };
+  contextMatches(event, payload) {
+    if (event === "console")
+      return true;
+    return payload.context === undefined || payload.context === this.contextId;
+  }
+  on(event, handler) {
+    return this.conn.on(BidiPageDriver.EVENT_MAP[event], (params) => {
+      const p = params;
+      if (this.contextMatches(event, p))
+        handler(p);
+    });
+  }
+  async waitForEvent(event, predicate, timeoutMs) {
+    try {
+      const p = await this.conn.waitFor(BidiPageDriver.EVENT_MAP[event], (params) => {
+        const p2 = params;
+        return this.contextMatches(event, p2) && (!predicate || predicate(p2));
+      }, timeoutMs);
+      return p;
+    } catch (e) {
+      throw mapBidiError(e);
+    }
+  }
+  async handleOneDialog(accept, promptText, timeoutMs) {
+    const opened = await this.conn.waitFor("browsingContext.userPromptOpened", (p) => p.context === this.contextId, timeoutMs).catch(() => {
+      throw driverError2("timeout", `handleDialog: no dialog opened within ${timeoutMs}ms`);
+    });
+    try {
+      await this.conn.send("browsingContext.handleUserPrompt", { context: this.contextId, accept, ...promptText !== undefined ? { userText: promptText } : {} });
+    } catch (e) {
+      throw mapBidiError(e);
+    }
+    return {
+      type: opened.type,
+      message: opened.message,
+      url: this.info.url,
+      ...opened.defaultValue !== undefined ? { defaultPrompt: opened.defaultValue } : {},
+      accept,
+      ...promptText !== undefined ? { promptText } : {},
+      handled: true
+    };
+  }
+  async handleDialog(accept, promptText, opts) {
+    if (opts?.autoMs !== undefined) {
+      const deadline = Date.now() + opts.autoMs;
+      const handled = [];
+      while (Date.now() < deadline) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+          break;
+        const d = await this.handleOneDialog(accept, promptText, Math.min(250, remaining)).catch(() => {
+          return;
+        });
+        if (d)
+          handled.push(d);
+      }
+      return { handled, count: handled.length };
+    }
+    return this.handleOneDialog(accept, promptText, opts?.timeoutMs ?? 15000);
+  }
+  async startBodyCapture() {
+    let collector;
+    try {
+      const res = await this.conn.send("network.addDataCollector", { dataTypes: ["response"], maxEncodedDataSize: 1e8, contexts: [this.contextId] });
+      collector = res.collector;
+    } catch (e) {
+      throw mapBidiError(e);
+    }
+    this.bodyCollector = collector;
+    return async () => {
+      await this.conn.send("network.removeDataCollector", { collector }).catch(() => {
+        return;
+      });
+      if (this.bodyCollector === collector)
+        this.bodyCollector = undefined;
+    };
+  }
+  async getResponseBody(requestId) {
+    if (!this.bodyCollector)
+      throw driverError2("unsupported", "getResponseBody: call startBodyCapture() first (network.responseBodyPostHoc is not supported)");
+    try {
+      const { bytes } = await this.conn.send("network.getData", { dataType: "response", collector: this.bodyCollector, request: requestId });
+      return bytes.type === "base64" ? { body: bytes.value, base64Encoded: true } : { body: bytes.value, base64Encoded: false };
+    } catch (e) {
+      throw mapBidiError(e);
+    }
+  }
+  async intercept(rules) {
+    let intercept;
+    try {
+      const res = await this.conn.send("network.addIntercept", { phases: ["beforeRequestSent"], contexts: [this.contextId] });
+      intercept = res.intercept;
+    } catch (e) {
+      throw mapBidiError(e);
+    }
+    const off = this.conn.on("network.beforeRequestSent", (params) => {
+      (async () => {
+        const req = params.request;
+        const rule = selectRule(rules, req.url, req.method);
+        if (!rule) {
+          await this.conn.send("network.continueRequest", { request: req.request }).catch(() => {
+            return;
+          });
+          return;
+        }
+        if (rule.delayMs)
+          await new Promise((r) => setTimeout(r, rule.delayMs));
+        const act = effectiveAction(rule, Math.random());
+        if (act === "fulfill") {
+          const built = buildFulfillParams(req.request, rule);
+          await this.conn.send("network.provideResponse", {
+            request: req.request,
+            statusCode: built.responseCode,
+            headers: built.responseHeaders.map((h) => ({ name: h.name, value: { type: "string", value: h.value } })),
+            body: { type: "base64", value: built.body }
+          }).catch(() => {
+            return;
+          });
+        } else if (act === "fail") {
+          await this.conn.send("network.failRequest", { request: req.request }).catch(() => {
+            return;
+          });
+        } else {
+          await this.conn.send("network.continueRequest", { request: req.request }).catch(() => {
+            return;
+          });
+        }
+      })();
+    });
+    return async () => {
+      off();
+      await this.conn.send("network.removeIntercept", { intercept }).catch(() => {
+        return;
+      });
+    };
+  }
+  async release() {
+    if (this.released)
+      return;
+    this.released = true;
+    this.conn.release();
+  }
+}
+
+class BidiBrowserDriver {
+  port;
+  timeoutMs;
+  scheme = "bidi";
+  lifetime = "session";
+  capabilities = BIDI_CAPABILITIES;
+  uidStability = "document-stamp";
+  snapshotFidelity = "dom-heuristic";
+  constructor(port, timeoutMs) {
+    this.port = port;
+    this.timeoutMs = timeoutMs;
+  }
+  async listPages() {
+    const conn = await getConnection(this.port, this.timeoutMs);
+    try {
+      const { contexts } = await conn.send("browsingContext.getTree", {}).catch((e) => {
+        throw mapBidiError(e);
+      });
+      return Promise.all(contexts.map((c) => pageInfoOf(conn, c)));
+    } finally {
+      conn.release();
+    }
+  }
+  async newPage(url) {
+    const conn = await getConnection(this.port, this.timeoutMs);
+    try {
+      const { context } = await conn.send("browsingContext.create", { type: "tab" }).catch((e) => {
+        throw mapBidiError(e);
+      });
+      if (url)
+        await conn.send("browsingContext.navigate", { context, url, wait: "complete" }).catch((e) => {
+          throw mapBidiError(e);
+        });
+      return { id: context, url: url ?? "about:blank", title: await safeTitle(conn, context) };
+    } finally {
+      conn.release();
+    }
+  }
+  async closePage(id) {
+    const conn = await getConnection(this.port, this.timeoutMs);
+    try {
+      await conn.send("browsingContext.close", { context: id }).catch((e) => {
+        throw mapBidiError(e);
+      });
+      return { success: true };
+    } finally {
+      conn.release();
+    }
+  }
+  async activatePage(id) {
+    const conn = await getConnection(this.port, this.timeoutMs);
+    try {
+      await conn.send("browsingContext.activate", { context: id }).catch((e) => {
+        throw mapBidiError(e);
+      });
+      const ctx = await resolveContext(conn, id);
+      return await pageInfoOf(conn, ctx);
+    } finally {
+      conn.release();
+    }
+  }
+  async page(selector) {
+    const conn = await getConnection(this.port, this.timeoutMs);
+    let ctx;
+    try {
+      ctx = await resolveContext(conn, selector);
+    } catch (e) {
+      conn.release();
+      throw e;
+    }
+    const info = await pageInfoOf(conn, ctx);
+    return new BidiPageDriver(conn, ctx.context, info, this);
+  }
+  async dispose() {
+    const conn = connections.get(this.port);
+    if (!conn)
+      return;
+    connections.delete(this.port);
+    conn.dispose();
+  }
+}
+function createFirefoxDriver(port, opts) {
+  return new BidiBrowserDriver(port, opts?.timeoutMs);
+}
+
+// src/bidi/launch.ts
+import { spawn as spawn2 } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { createConnection, createServer } from "node:net";
+import { tmpdir } from "node:os";
+import { join as join5 } from "node:path";
+function resolveBinary() {
+  const candidates = [
+    process.env.FIREFOX_BIN,
+    "/Applications/Firefox.app/Contents/MacOS/firefox",
+    "firefox"
+  ];
+  for (const c of candidates) {
+    if (c)
+      return c;
+  }
+  throw new Error("Firefox binary not found. Tried FIREFOX_BIN env var, " + "/Applications/Firefox.app/Contents/MacOS/firefox, and 'firefox' on PATH.");
+}
+function pickPort(requested) {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.once("error", (err) => {
+      if (requested !== undefined && err.code === "EADDRINUSE") {
+        reject(new Error(`port ${requested} is already in use`));
+        return;
+      }
+      reject(err);
+    });
+    server.listen(requested ?? 0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (addr === null || typeof addr === "string") {
+        server.close();
+        reject(new Error("failed to allocate a port"));
+        return;
+      }
+      const { port } = addr;
+      server.close(() => resolve(port));
+    });
+  });
+}
+function pollPort(port, deadlineMs) {
+  const start = Date.now();
+  return new Promise((resolve, reject) => {
+    const attempt = () => {
+      const sock = createConnection({ port, host: "127.0.0.1" });
+      const onFail = () => {
+        sock.destroy();
+        if (Date.now() - start >= deadlineMs) {
+          reject(new Error(`Firefox debug port ${port} did not accept a connection within ${deadlineMs}ms`));
+          return;
+        }
+        setTimeout(attempt, 100);
+      };
+      sock.once("connect", () => {
+        sock.destroy();
+        resolve();
+      });
+      sock.once("error", onFail);
+    };
+    attempt();
+  });
+}
+function waitForExit(proc, deadlineMs) {
+  return new Promise((resolve) => {
+    if (proc.exitCode !== null || proc.signalCode !== null) {
+      resolve();
+      return;
+    }
+    const timer = setTimeout(() => resolve(), deadlineMs);
+    proc.once("exit", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
+async function launchFirefox(opts = {}) {
+  const binary = resolveBinary();
+  const port = await pickPort(opts.port);
+  const isThrowaway = opts.profilePath === undefined;
+  const profilePath = opts.profilePath ?? mkdtempSync(join5(tmpdir(), "cdp-toolkit-ff-profile-"));
+  const args = ["--profile", profilePath, "--remote-debugging-port", String(port), "--no-remote"];
+  if (opts.headless)
+    args.push("--headless");
+  const proc = spawn2(binary, args, { stdio: "ignore", detached: false });
+  let closed = false;
+  const close = async () => {
+    if (closed)
+      return;
+    closed = true;
+    if (proc.exitCode === null && proc.signalCode === null) {
+      proc.kill("SIGTERM");
+      await waitForExit(proc, 5000);
+      if (proc.exitCode === null && proc.signalCode === null) {
+        proc.kill("SIGKILL");
+        await waitForExit(proc, 5000);
+      }
+    }
+    if (isThrowaway) {
+      rmSync(profilePath, { recursive: true, force: true });
+    }
+  };
+  const pid = proc.pid;
+  if (pid === undefined) {
+    await close();
+    throw new Error(`failed to spawn Firefox binary at ${binary}`);
+  }
+  const timeoutMs = opts.timeoutMs ?? 15000;
+  try {
+    await pollPort(port, timeoutMs);
+  } catch (err) {
+    await close();
+    throw err;
+  }
+  return { port, pid, profilePath, close };
+}
+
+// src/backend.ts
+function resolveBrowserKind(argv) {
+  const flagIdx = argv.indexOf("--browser");
+  const flagVal = flagIdx !== -1 ? argv[flagIdx + 1] : undefined;
+  const raw = flagVal ?? process.env.CDP_BROWSER ?? "chrome";
+  if (raw !== "chrome" && raw !== "firefox") {
+    throw new Error(`unknown --browser '${raw}': expected 'chrome' or 'firefox' (or set CDP_BROWSER)`);
+  }
+  return raw;
+}
+function stripBrowserFlag(argv) {
+  const out = [];
+  for (let i = 0;i < argv.length; i++) {
+    if (argv[i] === "--browser") {
+      i++;
+      continue;
+    }
+    out.push(argv[i]);
+  }
+  return out;
+}
+async function startFirefoxSession(opts) {
+  const launched = await launchFirefox({ headless: opts?.headless });
+  const driver = createFirefoxDriver(launched.port);
+  let disposed = false;
+  return {
+    driver,
+    async dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      await driver.dispose().catch(() => {
+        return;
+      });
+      await launched.close();
+    }
   };
 }
-function truncate(s, max = 600) {
-  const t = s.trim();
-  return t.length > max ? `${t.slice(0, max)}…` : t;
+var sessionPromise;
+function getOrCreateFirefoxSession() {
+  if (!sessionPromise)
+    sessionPromise = startFirefoxSession();
+  return sessionPromise;
+}
+async function disposeFirefoxSession() {
+  if (!sessionPromise)
+    return;
+  const p = sessionPromise;
+  sessionPromise = undefined;
+  await p.then((s) => s.dispose()).catch(() => {
+    return;
+  });
 }
 
-// src/tools/network_mock.ts
-function escapeRegExpChar(ch) {
-  return /[.*+?^${}()|[\]\\]/.test(ch) ? `\\${ch}` : ch;
+// src/capabilities.ts
+function capabilitiesFor(kind) {
+  return kind === "chrome" ? createCdpDriver().capabilities : createFirefoxDriver(0).capabilities;
 }
-function globToRegExp(pattern) {
-  let re = "";
-  for (let i = 0;i < pattern.length; i++) {
-    const ch = pattern[i];
-    if (ch === "\\") {
-      const next = pattern[i + 1];
-      if (next !== undefined) {
-        re += escapeRegExpChar(next);
-        i++;
-      } else {
-        re += "\\\\";
-      }
-    } else if (ch === "*") {
-      re += ".*";
-    } else if (ch === "?") {
-      re += ".";
+function toolAvailability(kind) {
+  const caps = capabilitiesFor(kind);
+  const available = [];
+  const unavailable = [];
+  for (const name of TOOL_NAMES) {
+    const required = REQUIRED_CAPABILITIES[name];
+    if (!required || required.every((c) => caps.has(c))) {
+      available.push(name);
     } else {
-      re += escapeRegExpChar(ch);
+      unavailable.push({ name, missing: required.filter((c) => !caps.has(c)) });
     }
   }
-  return new RegExp(`^${re}$`);
+  return { kind, available, unavailable };
 }
-function urlMatches(pattern, url) {
-  return globToRegExp(pattern).test(url);
+
+// src/bidi-tools.ts
+class BidiToolError extends Error {
 }
-function selectRule(rules, url, method) {
-  return rules.find((r) => urlMatches(r.urlPattern, url) && (!r.method || r.method.toUpperCase() === method.toUpperCase()));
+async function withPage3(driver, target, fn) {
+  const page = await driver.page(target);
+  try {
+    return await fn(page);
+  } finally {
+    await page.release();
+  }
 }
-function buildFulfillParams(requestId, rule) {
-  const merged = new Map;
-  merged.set("content-type", { name: "Content-Type", value: rule.contentType ?? "application/json" });
-  for (const [name, value] of Object.entries(rule.headers ?? {})) {
-    merged.set(name.toLowerCase(), { name, value });
+var consoleBuffers = new Map;
+var networkBuffers = new Map;
+function bufferFor(map, id) {
+  let b = map.get(id);
+  if (!b) {
+    b = [];
+    map.set(id, b);
   }
-  return {
-    requestId,
-    responseCode: rule.status ?? 200,
-    responseHeaders: [...merged.values()],
-    body: Buffer.from(rule.body ?? "", "utf8").toString("base64")
-  };
+  return b;
 }
-function effectiveAction(rule, rnd) {
-  if (rule.failRate !== undefined && rule.failRate > 0 && rnd < rule.failRate)
-    return "fail";
-  return rule.action;
+async function captureFresh(page, durationMs) {
+  const cBuf = bufferFor(consoleBuffers, page.info.id);
+  const nBuf = bufferFor(networkBuffers, page.info.id);
+  cBuf.length = 0;
+  nBuf.length = 0;
+  const offC = page.on("console", (p) => cBuf.push(p));
+  const offReq = page.on("network.request", (p) => nBuf.push({ ...p, phase: "request" }));
+  const offRes = page.on("network.response", (p) => nBuf.push({ ...p, phase: "response" }));
+  try {
+    await page.navigate({ reload: true }).catch(() => {
+      return;
+    });
+    await new Promise((r) => setTimeout(r, durationMs));
+  } finally {
+    offC();
+    offReq();
+    offRes();
+  }
 }
-var sessions = new Map;
-function delay3(ms) {
-  return new Promise((r) => setTimeout(r, ms));
+async function listConsoleMessages2(driver, args = {}) {
+  return withPage3(driver, args.target, async (page) => {
+    if (args.reload)
+      await captureFresh(page, args.durationMs ?? 2500);
+    const buf = bufferFor(consoleBuffers, page.info.id);
+    return { messages: [...buf], count: buf.length };
+  });
 }
-function registerHandler(session) {
-  session.conn.on("Fetch.requestPaused", (params) => {
-    const p = params;
-    session.chain = session.chain.then(async () => {
-      const rule = selectRule(session.rules, p.request.url, p.request.method);
-      if (!rule) {
-        await session.conn.send("Fetch.continueRequest", { requestId: p.requestId });
-        return;
-      }
-      if (rule.delayMs)
-        await delay3(rule.delayMs);
-      const act = effectiveAction(rule, Math.random());
-      if (act === "fulfill") {
-        await session.conn.send("Fetch.fulfillRequest", { ...buildFulfillParams(p.requestId, rule) });
-      } else if (act === "fail") {
-        await session.conn.send("Fetch.failRequest", { requestId: p.requestId, errorReason: rule.errorReason ?? "Failed" });
-      } else {
-        await session.conn.send("Fetch.continueRequest", { requestId: p.requestId });
-      }
-      rule.hits++;
-      session.intercepted.push({ url: p.request.url, method: p.request.method, action: act });
-    }).catch((e) => {
-      if (/closed|connection|Target|Inspected/i.test(String(e)))
-        session.dead = true;
-    });
+async function getConsoleMessage2(driver, args = {}) {
+  return withPage3(driver, args.target, async (page) => {
+    const buf = bufferFor(consoleBuffers, page.info.id);
+    const idx = args.index ?? 0;
+    const entry = buf[idx];
+    if (!entry)
+      throw new BidiToolError(`no console message at index ${idx}; run list_console_messages first`);
+    return entry;
   });
 }
-async function mockRequest(args) {
+async function listNetworkRequests2(driver, args = {}) {
+  return withPage3(driver, args.target, async (page) => {
+    if (args.reload)
+      await captureFresh(page, args.durationMs ?? 2500);
+    let buf = bufferFor(networkBuffers, page.info.id);
+    if (args.filterUrl)
+      buf = buf.filter((r) => typeof r.url === "string" && r.url.includes(args.filterUrl));
+    return { requests: buf, count: buf.length };
+  });
+}
+async function getNetworkRequest2(driver, args = {}) {
+  if (!args.requestId && !args.url)
+    throw new BidiToolError("get_network_request requires requestId or url");
+  return withPage3(driver, args.target, async (page) => {
+    const buf = bufferFor(networkBuffers, page.info.id);
+    const found = args.requestId ? buf.find((r) => r.requestId === args.requestId || r.request === args.requestId) : buf.find((r) => typeof r.url === "string" && r.url.includes(args.url));
+    if (!found)
+      throw new BidiToolError("no matching network request in the current buffer; run list_network_requests first");
+    return found;
+  });
+}
+var mockSessions = new Map;
+async function mockRequest2(driver, args) {
   if (!args.urlPattern)
-    throw new CdpError("mock_request requires a { urlPattern }");
-  const rule = {
-    urlPattern: args.urlPattern,
-    action: args.action ?? "fulfill",
-    status: args.status,
-    body: args.body,
-    contentType: args.contentType,
-    headers: args.headers,
-    errorReason: args.errorReason,
-    method: args.method,
-    delayMs: args.delayMs,
-    failRate: args.failRate,
-    hits: 0
-  };
-  const resolved = await resolveTarget(args.target);
-  let session = sessions.get(resolved.id);
-  if (session && !session.dead) {
-    const idx = session.rules.findIndex((r) => r.urlPattern === rule.urlPattern && (r.method ?? "") === (rule.method ?? ""));
-    if (idx >= 0)
-      session.rules[idx] = rule;
-    else
-      session.rules.push(rule);
-    await session.conn.send("Fetch.enable", { patterns: session.rules.map((r) => ({ urlPattern: r.urlPattern })) });
-  } else {
-    const { conn, target } = await openPage(resolved.id);
-    session = { conn, target, rules: [rule], intercepted: [], chain: Promise.resolve(), dead: false };
-    registerHandler(session);
-    await conn.send("Fetch.enable", { patterns: [{ urlPattern: rule.urlPattern }] });
-    sessions.set(target.id, session);
-  }
-  let reloaded = false;
-  if (args.reload) {
-    await session.conn.send("Page.enable");
-    await session.conn.send("Page.reload", { ignoreCache: true });
-    await delay3(800);
-    reloaded = true;
-  }
-  return {
-    target: { id: session.target.id, url: session.target.url, title: session.target.title },
-    pattern: rule.urlPattern,
-    ruleCount: session.rules.length,
-    reloaded
-  };
+    throw new BidiToolError("mock_request requires a { urlPattern }");
+  return withPage3(driver, args.target, async (page) => {
+    const existing = mockSessions.get(page.info.id);
+    const rule = {
+      urlPattern: args.urlPattern,
+      method: args.method,
+      action: args.action ?? "fulfill",
+      status: args.status,
+      body: args.body,
+      contentType: args.contentType,
+      headers: args.headers,
+      errorReason: args.errorReason,
+      delayMs: args.delayMs,
+      failRate: args.failRate,
+      hits: 0
+    };
+    const rules = existing ? [...existing.rules, rule] : [rule];
+    if (existing)
+      await existing.dispose().catch(() => {
+        return;
+      });
+    const dispose = await page.intercept(rules);
+    mockSessions.set(page.info.id, { rules, dispose });
+    if (args.reload)
+      await page.navigate({ reload: true }).catch(() => {
+        return;
+      });
+    return { target: page.info, rule: { urlPattern: rule.urlPattern, action: rule.action }, ruleCount: rules.length };
+  });
 }
-async function listMocks(_args = {}) {
-  for (const [id, s] of sessions) {
-    if (s.dead) {
-      try {
-        s.conn.close();
-      } catch {}
-      sessions.delete(id);
-      continue;
-    }
-    try {
-      await s.conn.send("Runtime.evaluate", { expression: "1", returnByValue: true }, { timeoutMs: 3000 });
-    } catch {
-      try {
-        s.conn.close();
-      } catch {}
-      sessions.delete(id);
-    }
-  }
-  const mocks = [...sessions.values()].map((s) => ({
-    target: { id: s.target.id, url: s.target.url, title: s.target.title },
-    rules: s.rules.map((r) => ({ urlPattern: r.urlPattern, action: r.action, method: r.method, hits: r.hits })),
-    hits: s.intercepted.length
+async function listMocks2(_driver, _args = {}) {
+  const sessions2 = [...mockSessions.entries()].map(([id, s]) => ({
+    target: id,
+    rules: s.rules.map((r) => ({ urlPattern: r.urlPattern, action: r.action, method: r.method }))
   }));
-  return { count: mocks.length, mocks };
+  return { sessions: sessions2 };
 }
-async function clearMocks(args = {}) {
-  let ids;
+async function clearMocks2(driver, args = {}) {
   if (args.all) {
-    ids = [...sessions.keys()];
-  } else {
-    const resolved = await resolveTarget(args.target);
-    ids = sessions.has(resolved.id) ? [resolved.id] : [];
-  }
-  let cleared = 0;
-  for (const id of ids) {
-    const s = sessions.get(id);
-    if (!s)
-      continue;
-    try {
-      await s.conn.send("Fetch.disable");
-    } catch {}
-    try {
-      s.conn.close();
-    } catch {}
-    sessions.delete(id);
-    cleared++;
+    let n = 0;
+    for (const [, s] of mockSessions) {
+      await s.dispose().catch(() => {
+        return;
+      });
+      n++;
+    }
+    mockSessions.clear();
+    return { cleared: n };
   }
-  return { cleared };
+  return withPage3(driver, args.target, async (page) => {
+    const existing = mockSessions.get(page.info.id);
+    if (!existing)
+      return { cleared: 0 };
+    await existing.dispose().catch(() => {
+      return;
+    });
+    mockSessions.delete(page.info.id);
+    return { cleared: 1 };
+  });
 }
+var BIDI_ONLY_TOOLS = {
+  list_console_messages: listConsoleMessages2,
+  get_console_message: getConsoleMessage2,
+  list_network_requests: listNetworkRequests2,
+  get_network_request: getNetworkRequest2,
+  mock_request: mockRequest2,
+  list_mocks: listMocks2,
+  clear_mocks: clearMocks2
+};
 
-// src/index.ts
-var TOOLS = {
-  list_pages: listPages,
-  new_page: newPage,
-  close_page: closePage,
-  select_page: selectPage,
-  navigate_page: navigatePage,
-  wait_for: waitForText,
-  evaluate_script: evaluateScript,
-  take_snapshot: takeSnapshot,
-  click,
-  hover,
-  drag,
-  fill,
-  fill_form: fillForm,
-  type_text: typeText,
-  press_key: pressKey,
-  upload_file: uploadFile,
-  take_screenshot: takeScreenshot,
-  emulate,
-  resize_page: resizePage,
-  handle_dialog: handleDialog,
-  list_console_messages: listConsoleMessages,
-  get_console_message: getConsoleMessage,
-  list_network_requests: listNetworkRequests,
-  get_network_request: getNetworkRequest,
-  performance_start_trace: performanceStartTrace,
-  performance_stop_trace: performanceStopTrace,
-  performance_analyze_insight: performanceAnalyzeInsight,
-  performance_trace: performanceTrace,
-  take_heapsnapshot: takeHeapsnapshot,
-  lighthouse_audit: lighthouseAudit,
-  mock_request: mockRequest,
-  list_mocks: listMocks,
-  clear_mocks: clearMocks
+// src/firefox-tools.ts
+var FIREFOX_TOOLS = {
+  ...SHARED_TOOLS,
+  ...BIDI_ONLY_TOOLS,
+  ...LEASE_TOOLS
 };
-var TOOL_NAMES = Object.keys(TOOLS);
 
 // src/cli.ts
-var USAGE = `cdp-toolkit — raw single-target CDP, 29-tool chrome-devtools-mcp parity.
+var USAGE = `cdp-toolkit: raw single-target CDP, 29-tool chrome-devtools-mcp parity, plus a Firefox backend over WebDriver BiDi.
 
 Usage:
-  bun run src/cli.ts <tool> [--target <sel>] [--json '<obj>'] [--<key> <value> ...]
-  bun run src/cli.ts --list
+  bun run src/cli.ts <tool> [--browser chrome|firefox] [--target <sel>] [--json '<obj>'] [--<key> <value> ...]
+  bun run src/cli.ts --list [--browser chrome|firefox]
+  bun run src/cli.ts --capabilities [--browser chrome|firefox]
 
 Examples:
   bun run src/cli.ts list_pages
@@ -2019,9 +4169,19 @@ Examples:
   bun run src/cli.ts click --target index:0 --uid 42
   bun run src/cli.ts evaluate_script --json '{"expression":"1+2"}'
   bun run src/cli.ts take_screenshot --target url:example --fullPage true
+  bun run src/cli.ts --browser firefox take_snapshot
+  bun run src/cli.ts --capabilities --browser firefox
+
+Backend selection: --browser chrome|firefox, else the CDP_BROWSER env var, else "chrome" (default,
+zero behavior change for existing users). Firefox is LAUNCHED per invocation (it cannot be attached
+to), used for exactly one tool call, then disposed before the process exits.
 
 Target selector grammar: active | index:N | url:<substr> | title:<substr> | <targetId>
-Run with --list to print every available tool name.`;
+Leases: pass --lease <token> to act on a tab another agent claimed with claim_page (MCP only).
+Run list_leases to see who holds what; release_page --lease <token> gives a lease back.
+Run with --list to print every tool name available under the selected backend.
+Run with --capabilities to see, per tool, whether it is available and (if not) which capability
+the selected backend is missing.`;
 function coerce(raw) {
   if (raw === "true")
     return true;
@@ -2033,7 +4193,7 @@ function coerce(raw) {
   return raw;
 }
 function parseArgv(argv) {
-  const out = { list: false, args: {} };
+  const out = { list: false, capabilities: false, args: {} };
   let jsonObj;
   const flagPairs = [];
   for (let i = 0;i < argv.length; i++) {
@@ -2042,6 +4202,10 @@ function parseArgv(argv) {
       out.list = true;
       continue;
     }
+    if (token === "--capabilities") {
+      out.capabilities = true;
+      continue;
+    }
     if (token.startsWith("--")) {
       const key = token.slice(2);
       const next = argv[i + 1];
@@ -2077,9 +4241,25 @@ function isToolName(name) {
   return Object.prototype.hasOwnProperty.call(TOOLS, name);
 }
 async function main() {
-  const parsed = parseArgv(process.argv.slice(2));
+  const rawArgv = process.argv.slice(2);
+  const browser = resolveBrowserKind(rawArgv);
+  const parsed = parseArgv(stripBrowserFlag(rawArgv));
+  const availability = toolAvailability(browser);
+  const availableSet = new Set(availability.available);
+  if (parsed.capabilities) {
+    const lines = [`backend: ${browser}`, "", "available:"];
+    for (const name of availability.available)
+      lines.push(`  ${name}`);
+    lines.push("", "unavailable:");
+    for (const u of availability.unavailable)
+      lines.push(`  ${u.name}  (needs: ${u.missing.join(", ")})`);
+    process.stdout.write(`${lines.join(`
+`)}
+`);
+    return 0;
+  }
   if (parsed.list) {
-    process.stdout.write(`${TOOL_NAMES.join(`
+    process.stdout.write(`${availability.available.join(`
 `)}
 `);
     return 0;
@@ -2094,11 +4274,46 @@ async function main() {
 `);
     return 1;
   }
-  const fn = TOOLS[parsed.tool];
-  const result = await fn(parsed.args);
-  process.stdout.write(`${JSON.stringify(result, null, 2)}
+  if (!availableSet.has(parsed.tool)) {
+    const gap = availability.unavailable.find((u) => u.name === parsed.tool);
+    process.stderr.write(`${JSON.stringify({
+      error: `tool '${parsed.tool}' is not available under --browser ${browser}${gap ? ` (needs: ${gap.missing.join(", ")})` : ""}. Run --capabilities --browser ${browser} to see the full list.`
+    })}
+`);
+    return 1;
+  }
+  if (parsed.tool === "claim_page") {
+    process.stderr.write(`${JSON.stringify({
+      error: "claim_page is not available from the CLI: a CLI invocation is one process per call, so the lease it claimed would be reclaimable immediately by the dead-pid rule. Claim from the cdp-toolkit MCP server, which is long lived, then pass the token to CLI calls with --lease <token>."
+    })}
+`);
+    return 1;
+  }
+  const tool = parsed.tool;
+  return withLeaseScope(leaseFromArgs(parsed.args), async () => {
+    if (browser === "chrome") {
+      const fn = TOOLS[tool];
+      const result = await fn(parsed.args);
+      process.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
-  return 0;
+      return 0;
+    }
+    const neutralFn = FIREFOX_TOOLS[tool];
+    if (!neutralFn) {
+      process.stderr.write(`${JSON.stringify({ error: `tool '${tool}' has no Firefox implementation wired` })}
+`);
+      return 1;
+    }
+    const session = await startFirefoxSession();
+    try {
+      const result = await neutralFn(session.driver, parsed.args);
+      process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+      return 0;
+    } finally {
+      await session.dispose();
+    }
+  });
 }
 main().then((code) => process.exit(code)).catch((err) => {
   const message = err instanceof Error ? err.message : String(err);